tabc 0.2.0__tar.gz → 0.2.2__tar.gz

tabc-0.2.2/CHANGELOG.md

@@ -0,0 +1,173 @@
+# Changelog
+
+## 0.2.2 — 2026-10-17
+
+### Changed
+
+- `register` treats `--kind` case-insensitively and stores it in lowercase.
+  `--kind OpenCode` registers `opencode`.
+- Terminal route capture at a detached session boundary no longer requires a
+  recognized Codex or Claude CLI. The immediate session-boundary parent
+  qualifies when it belongs to the same OS user, leads the target terminal's
+  foreground process group, and reads standard input from that terminal.
+  Process state, executable path, and standard input are checked again before
+  the route is accepted. Product names and install directories are not an
+  admission list.
+- Codex queue selection under `--kind codex --auto-enter on` and its fallback
+  rules are unchanged. Because the kind is case-folded, `--kind Codex` now
+  selects the same queue route.
+
+### Notes
+
+- The check verifies terminal ownership, not whether the program is an agent.
+  A foreground program that reads the terminal can qualify even if it is not
+  an agent. Automatic Enter remains a separate opt-in.
+- No dedicated adapter for another agent product is added. The MCP adapter
+  still does not wake an agent.
+
+### Upgrade notes (from 0.2.1)
+
+- The ledger schema is unchanged. Nodes, signing keys, messages, delivery
+  states, TACs, routes, and Codex queue receipts are kept.
+- Stop `tabus.doorbell`, install 0.2.2, restart `tabd`, then start one
+  `tabus.doorbell` from the same installation:
+
+```bash
+python -m pip install --upgrade "tabc==0.2.2"
+# Or, for desktop MCP support:
+python -m pip install --upgrade "tabc[mcp]==0.2.2"
+```
+
+- Stored routes are not migrated. A failed capture does not replace an
+  existing route. Register again from the intended terminal, then confirm one
+  notification arrives.
+- If a desktop client runs `tabc-mcp`, restart that MCP process from the client
+  after the upgrade so it loads the new installation.
+- After restart, `tabc --version` and `tabd --version` report 0.2.2.
+
+## 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
+
+- An optional local stdio MCP adapter for desktop agents.
+- Structured refusal codes and details for send and TAC errors.
+- UTF-8 byte limits: 1,024 bytes for a subject, 65,536 bytes for a body, and
+  524,288 bytes for an HTTP request. Oversized input is rejected before storage.
+- Server-minted canonical UUIDs for TAC identity. TAC names remain unique,
+  searchable, and renameable without changing the UUID.
+- TAC `rename`, `check`, and member-scoped literal `search` commands.
+- A copy-first migration tool for existing string TAC identifiers.
+- Unicode-consistent literal TAC search across names, descriptions, summaries,
+  subjects, and bodies, including NFC/NFD-equivalent text.
+
+### Changed
+
+- MCP responses preserve structured error codes and details from tabd.
+- TAC commands address converted topics by UUID. Names are used for creation,
+  display, and search.
+- `tac show --node` advances only the returned deliveries to `INJECTED`.
+  It does not mark them `READ`, and older unreturned messages may still block a send.
+- The pending count printed after a send is scoped to that sender and recipient.
+  `tabc who` remains the total unread view.
+- Terminal route capture now validates the native foreground Codex or Claude CLI
+  at a detached session boundary. Unknown launch modes and mismatched terminals
+  fail closed. New or moved routes keep automatic Enter off unless explicitly
+  enabled with `register --auto-enter on`.
+
+### Protocol details
+
+- A fresh 0.2.0 ledger mints canonical lowercase, hyphenated UUIDs for TACs.
+  Existing ledgers retain string TAC IDs until explicit conversion.
+- A TAC name is trimmed at its edges and compared as
+  `NFC(casefold(NFC(name)))`. Control, format, surrogate, private-use, unassigned,
+  and non-ordinary whitespace characters are refused. Unicode category results
+  follow the Python version running tabd.
+- A partially converted ledger that has identity columns but still contains
+  string TAC IDs refuses TAC creation and rename with `TAC_NOT_CONVERTED`.
+- Missing canonical TAC IDs return `TAC_NOT_FOUND`. Read-only name lookup can
+  report `exists: false`; names are not accepted where a TAC UUID designates the
+  target.
+- Structured server refusal codes and retry rules are listed in
+  [GUIDE.md](GUIDE.md#refusal-codes). MCP preserves those fields without truncation.
+
+### Upgrade note
+
+An upgrade from 0.1.6 preserves nodes, messages, delivery states, TAC membership,
+names, and labels. Package installation and server startup do not convert TAC IDs.
+Pre-0.2.0 ledgers keep their string TAC identifiers until explicitly converted.
+Stop `tabus.doorbell` and `tabd`. Confirm that `<ledger.db>-wal` is absent or
+empty (0 bytes). A remaining empty WAL or SHM file is safe. If the WAL is not
+empty, start `tabd` and stop it cleanly, then check again. Back up the main
+database only after the WAL is absent or empty. Install the required package,
+then run a read-only preflight and write a separate converted database:
+
+```bash
+python -m pip install --upgrade "tabc==0.2.0"
+# Or, for desktop MCP support:
+python -m pip install --upgrade "tabc[mcp]==0.2.0"
+
+python -m tabus.tac_migration <ledger.db>
+python -m tabus.tac_migration <ledger.db> --output <converted.db>
+```
+
+Replace only the main database file after the row counts and converted database
+are verified. Do not replace it while its WAL file is non-empty. A remaining
+empty WAL or SHM file is safe. Restart `tabd` first, then restart
+`tabus.doorbell`. Do not run old and new daemons against the same active ledger
+during the swap.
+After conversion, commands that use a TAC name instead of its UUID are refused
+with `TAC_ID_INVALID`. Scripts must use the UUID printed by `tabc tac ls`.
+After restart, use `tabc --version` and `tabd --version` to confirm that both
+commands resolve to 0.2.0.
+
+When replacing an installed notifier, stop the old `tabus.doorbell` first, restart
+`tabd`, then start the new notifier. See the registration notes in
+[README.md](README.md#node-identity-and-signing-keys).

{tabc-0.2.0 → tabc-0.2.2}/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.2}/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.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: tabc
-Version: 0.2.0
+Version: 0.2.2
 Summary: A shared inbox for AI agents and programs on one machine
 License: MIT License
         
@@ -37,11 +37,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Communications
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: cryptography>=41
 Provides-Extra: mcp
-Requires-Dist: mcp<2,>=1.27.1; python_version >= "3.10" and extra == "mcp"
-Dynamic: license-file
+License-File: LICENSE
 
 # tabc
 
@@ -102,12 +99,51 @@ 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.1
+
+The ledger schema is unchanged. Nodes, signing keys, messages, delivery states,
+TACs, routes, and Codex queue receipts 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.2"
+# Or, when the local desktop MCP adapter is required:
+python -m pip install --upgrade "tabc[mcp]==0.2.2"
+```
+
+`--kind` is now case-insensitive; `--kind Codex` selects the same Codex queue
+route as `--kind codex`. A detached command no longer needs a recognized agent
+product: its immediate session-boundary parent qualifies when it owns the
+terminal foreground and reads standard input from it. The check proves terminal
+ownership, not that the program is an agent. Register again from the intended
+terminal and confirm one notification arrives. Codex queue rules are otherwise
+unchanged. See the
+[changelog](https://github.com/jultabc/tabc/blob/main/CHANGELOG.md).
+
+## 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 +161,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" and "Updating from 0.2.1".
 
 ## Commands
 
@@ -136,7 +173,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 +200,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.2}/PYPI.md

@@ -57,12 +57,51 @@ 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.1
+
+The ledger schema is unchanged. Nodes, signing keys, messages, delivery states,
+TACs, routes, and Codex queue receipts 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.2"
+# Or, when the local desktop MCP adapter is required:
+python -m pip install --upgrade "tabc[mcp]==0.2.2"
+```
+
+`--kind` is now case-insensitive; `--kind Codex` selects the same Codex queue
+route as `--kind codex`. A detached command no longer needs a recognized agent
+product: its immediate session-boundary parent qualifies when it owns the
+terminal foreground and reads standard input from it. The check proves terminal
+ownership, not that the program is an agent. Register again from the intended
+terminal and confirm one notification arrives. Codex queue rules are otherwise
+unchanged. See the
+[changelog](https://github.com/jultabc/tabc/blob/main/CHANGELOG.md).
+
+## 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 +119,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" and "Updating from 0.2.1".
 
 ## Commands
 
@@ -91,7 +131,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 +158,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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tabc"
-version = "0.2.0"
+version = "0.2.2"
 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.2/tabc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: tabc
-Version: 0.2.0
+Version: 0.2.2
 Summary: A shared inbox for AI agents and programs on one machine
 License: MIT License
         
@@ -37,11 +37,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Communications
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: cryptography>=41
 Provides-Extra: mcp
-Requires-Dist: mcp<2,>=1.27.1; python_version >= "3.10" and extra == "mcp"
-Dynamic: license-file
+License-File: LICENSE
 
 # tabc
 
@@ -102,12 +99,51 @@ 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.1
+
+The ledger schema is unchanged. Nodes, signing keys, messages, delivery states,
+TACs, routes, and Codex queue receipts 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.2"
+# Or, when the local desktop MCP adapter is required:
+python -m pip install --upgrade "tabc[mcp]==0.2.2"
+```
+
+`--kind` is now case-insensitive; `--kind Codex` selects the same Codex queue
+route as `--kind codex`. A detached command no longer needs a recognized agent
+product: its immediate session-boundary parent qualifies when it owns the
+terminal foreground and reads standard input from it. The check proves terminal
+ownership, not that the program is an agent. Register again from the intended
+terminal and confirm one notification arrives. Codex queue rules are otherwise
+unchanged. See the
+[changelog](https://github.com/jultabc/tabc/blob/main/CHANGELOG.md).
+
+## 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 +161,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" and "Updating from 0.2.1".
 
 ## Commands
 
@@ -136,7 +173,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 +200,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.2}/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.2}/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.2"
 PROTOCOL_VERSION = "tabus.v1"
 
 # TTLs. Past these, a derived status counts as old.

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

@@ -251,10 +251,17 @@ def fn_config(a):
 
 def fn_register(a):
     node = _require_acting_node(a.node)
+    a.kind = a.kind.casefold()
     payload = {"node": node, "kind": a.kind}
     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 +297,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 +1085,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.2/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.2}/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.2}/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 = {}
 

{tabc-0.2.0 → tabc-0.2.2}/tabus/route_capture.py

@@ -6,8 +6,8 @@ that terminal.  A detached shared runner can therefore carry one tab's route,
 allocate a fresh PTY, and still register the stale tab.  Route capture accepts
 the inherited key only when its resolved TTY equals the controlling TTY of this
 process or a same-session ancestor. A detached command may also use its immediate
-session-boundary parent when that parent is a recognized native interactive CLI
-and the foreground process-group leader of the target terminal.
+session-boundary parent when that parent owns the target terminal foreground
+process group and its standard input is that same terminal, regardless of kind.
 """
 
 import os
@@ -99,7 +99,7 @@ def terminal_tty(
 
     ``ps`` is used instead of ``/proc`` so this works on both macOS and Linux.
     Any lookup failure is a negative result. The cross-session fallback is
-    restricted to a checked native foreground CLI, not arbitrary ancestors.
+    restricted to a checked foreground terminal owner, not arbitrary ancestors.
     """
     inspect = process_row or _process_row
     inspect_session = process_session or _session_id

{tabc-0.2.0 → tabc-0.2.2}/tabus/terminal_frontend.py

@@ -1,7 +1,7 @@
-"""Recognize a foreground native agent CLI, never a generic terminal ancestor.
+"""Verify a foreground terminal owner without a product-name allowlist.
 
 This is local routing evidence, not an isolation boundary against a malicious
-process running as the same OS user. Unknown launch modes fail closed.
+process running as the same OS user. Missing terminal evidence fails closed.
 """
 
 import ctypes
@@ -57,7 +57,7 @@ def executable_kind(executable, user_home):
 
 
 def interactive_arguments(kind, argv):
-    """Allow inspected interactive modes only; no arbitrary prompt/subcommand."""
+    """Legacy argument classifier; not used by generic route registration."""
     if not argv or os.path.basename(argv[0]) != kind:
         return False
     flags = {
@@ -120,11 +120,27 @@ def process_info(pid):
             fields[4], args)
 
 
+def input_terminal(pid):
+    """Resolve fd 0, not inherited environment variables or a process name."""
+    if sys.platform.startswith("linux"):
+        return os.path.realpath(os.readlink(f"/proc/{int(pid)}/fd/0"))
+    if sys.platform == "darwin":
+        result = subprocess.run(
+            ["/usr/sbin/lsof", "-a", "-p", str(int(pid)), "-d", "0", "-Fn"],
+            capture_output=True, text=True, timeout=1, check=False,
+        )
+        names = [line[1:] for line in result.stdout.splitlines() if line.startswith("n")]
+        if result.returncode == 0 and len(names) == 1:
+            return names[0]
+    return None
+
+
 def foreground_frontend_tty(pid, expected_tty, inspect=None, executable=None,
-                            uid=None, user_home=None):
+                            uid=None, user_home=None, stdin_terminal=None):
     """Only the boundary parent itself may qualify; never walk past a server."""
     inspect = inspect or process_info
     executable = executable or native_executable
+    stdin_terminal = stdin_terminal or input_terminal
     uid = os.getuid() if uid is None else uid
     try:
         user_home = pwd.getpwuid(uid).pw_dir if user_home is None else user_home
@@ -135,11 +151,15 @@ def foreground_frontend_tty(pid, expected_tty, inspect=None, executable=None,
         if owner != uid or not (pid == group == foreground) or tty != expected_tty:
             return None
         path = executable(pid)
-        kind = executable_kind(path, user_home) if path else None
-        if kind is None or not interactive_arguments(kind, argv):
+        # Generic terminal routing is independent of kind and installation path.
+        # The immediate boundary parent must own the foreground group AND read
+        # from that terminal. A pipe-backed server is not a terminal recipient.
+        input_path = "/dev/" + expected_tty.removeprefix("/dev/")
+        if not path or stdin_terminal(pid) != input_path:
             return None
         # Recheck mutable process state around executable and command inspection.
-        if inspect(pid) != before or executable(pid) != path:
+        if (inspect(pid) != before or executable(pid) != path
+                or stdin_terminal(pid) != input_path):
             return None
         return tty
     except (OSError, ValueError, TypeError, KeyError, ctypes.ArgumentError,

tabc-0.2.0/CHANGELOG.md

@@ -1,80 +0,0 @@
-# Changelog
-
-## 0.2.0 — Unreleased
-
-### Added
-
-- An optional local stdio MCP adapter for desktop agents.
-- Structured refusal codes and details for send and TAC errors.
-- UTF-8 byte limits: 1,024 bytes for a subject, 65,536 bytes for a body, and
-  524,288 bytes for an HTTP request. Oversized input is rejected before storage.
-- Server-minted canonical UUIDs for TAC identity. TAC names remain unique,
-  searchable, and renameable without changing the UUID.
-- TAC `rename`, `check`, and member-scoped literal `search` commands.
-- A copy-first migration tool for existing string TAC identifiers.
-- Unicode-consistent literal TAC search across names, descriptions, summaries,
-  subjects, and bodies, including NFC/NFD-equivalent text.
-
-### Changed
-
-- MCP responses preserve structured error codes and details from tabd.
-- TAC commands address converted topics by UUID. Names are used for creation,
-  display, and search.
-- `tac show --node` advances only the returned deliveries to `INJECTED`.
-  It does not mark them `READ`, and older unreturned messages may still block a send.
-- The pending count printed after a send is scoped to that sender and recipient.
-  `tabc who` remains the total unread view.
-- Terminal route capture now validates the native foreground Codex or Claude CLI
-  at a detached session boundary. Unknown launch modes and mismatched terminals
-  fail closed. New or moved routes keep automatic Enter off unless explicitly
-  enabled with `register --auto-enter on`.
-
-### Protocol details
-
-- A fresh 0.2.0 ledger mints canonical lowercase, hyphenated UUIDs for TACs.
-  Existing ledgers retain string TAC IDs until explicit conversion.
-- A TAC name is trimmed at its edges and compared as
-  `NFC(casefold(NFC(name)))`. Control, format, surrogate, private-use, unassigned,
-  and non-ordinary whitespace characters are refused. Unicode category results
-  follow the Python version running tabd.
-- A partially converted ledger that has identity columns but still contains
-  string TAC IDs refuses TAC creation and rename with `TAC_NOT_CONVERTED`.
-- Missing canonical TAC IDs return `TAC_NOT_FOUND`. Read-only name lookup can
-  report `exists: false`; names are not accepted where a TAC UUID designates the
-  target.
-- Structured server refusal codes and retry rules are listed in
-  [GUIDE.md](GUIDE.md#refusal-codes). MCP preserves those fields without truncation.
-
-### Upgrade note
-
-An upgrade from 0.1.6 preserves nodes, messages, delivery states, TAC membership,
-names, and labels. Package installation and server startup do not convert TAC IDs.
-Pre-0.2.0 ledgers keep their string TAC identifiers until explicitly converted.
-Stop `tabus.doorbell` and `tabd`. Confirm that `<ledger.db>-wal` is absent or
-empty (0 bytes). A remaining empty WAL or SHM file is safe. If the WAL is not
-empty, start `tabd` and stop it cleanly, then check again. Back up the main
-database only after the WAL is absent or empty. Install the required package,
-then run a read-only preflight and write a separate converted database:
-
-```bash
-python -m pip install --upgrade "tabc==0.2.0"
-# Or, for desktop MCP support:
-python -m pip install --upgrade "tabc[mcp]==0.2.0"
-
-python -m tabus.tac_migration <ledger.db>
-python -m tabus.tac_migration <ledger.db> --output <converted.db>
-```
-
-Replace only the main database file after the row counts and converted database
-are verified. Do not replace it while its WAL file is non-empty. A remaining
-empty WAL or SHM file is safe. Restart `tabd` first, then restart
-`tabus.doorbell`. Do not run old and new daemons against the same active ledger
-during the swap.
-After conversion, commands that use a TAC name instead of its UUID are refused
-with `TAC_ID_INVALID`. Scripts must use the UUID printed by `tabc tac ls`.
-After restart, use `tabc --version` and `tabd --version` to confirm that both
-commands resolve to 0.2.0.
-
-When replacing an installed notifier, stop the old `tabus.doorbell` first, restart
-`tabd`, then start the new notifier. See the registration notes in
-[README.md](README.md#node-identity-and-signing-keys).