greprag 5.83.0 → 5.83.1

package/dist/commands/collision-check.js

@@ -114,22 +114,25 @@ function dedupePeers(peers, announced) {
     const union = Array.from(new Set([...announced, ...peers.map(p => p.short)]));
     return { fresh, union };
 }
+// adr: adr/delivery-announce-pilot.md
 /** The LOUD directive — same `additionalContext` shape as the arm directive,
- *  naming each peer + instructing message-then-worktree. PURE. */
+ *  naming each peer + instructing message-then-worktree. PURE.
+ *  It asks no heads-up of Claude Code peers: Claude Code holds a message to a
+ *  session in another permission mode for that session's user and may let it
+ *  expire, and the sender cannot see modes, so silence there is not approval.
+ *  Delivery is the per-harness Delivery announce's alone, so step 3 defers. */
 function buildCollisionDirective(peers, myShort, alias) {
     const handle = alias || '<handle>';
     const lines = peers.map(p => `  · ${p.short}${p.title ? ` — "${p.title}"` : ''}`);
     const plural = peers.length === 1 ? '' : 's';
     return (`COLLISION DETECTED — ${peers.length} other live session${plural} working in this same repo right now:\n`
         + lines.join('\n') + '\n'
-        + `Coordinate BEFORE touching shared files: (1) message each peer now with a contextual heads-up — `
+        + `Coordinate BEFORE touching shared files: (1) message each peer above now with a contextual heads-up — `
         + `Codex peers: use \`codex_app.list_threads\` to find the task and its repo/workspace, then \`codex_app.send_message_to_thread\` to send the heads-up; `
-        + `Claude Code peers: use your harness's own session list + send tools — the 8-hex ids above are GREPRAG addresses and are not accepted by them; `
         + `peers OUTSIDE this harness (opencode / Grok / another tenant): \`greprag send "…what you're about to touch…" --to ${handle}@greprag.com/<their-8hex> --from-session ${myShort}\` `
         + `(YOU compose and send it — this is a notice, not an auto-send; recipients reply only for a concrete conflict, silence is approval, and you never poll or wait; watcher rows are not the Codex peer source of truth); `
-        + `(2) do your code work in a worktree on its own branch (\`git worktree add .claude/worktrees/<slug> -b <branch>\`); `
-        + `(3) at completion resolve \`.greprag/delivery.json\`, send one fire-and-forget delivery notice to PEER sessions only — never to a chip (title \`Chip: \` / \`Chip <Label>: \`), which reports to its own parent and has no business with merge, deploy or master — then continue immediately without polling, waiting, status reads, or follow-ups; `
-        + `sweep every ready same-repo commit, ignore all uncommitted and untracked work, resolve conflicts directly, and finish the declared push/deploy/release path. Never edit the shared default checkout concurrently.`);
+        + `(2) do your code work in a worktree on its own branch (\`git worktree add .claude/worktrees/<slug> -b <branch>\`), never in the shared default checkout; `
+        + `(3) at delivery, notify peers only as this harness's Delivery announce says.`);
 }
 /** Reduce the watcher list to OTHER live sessions that are NOT in my repo
  *  (cross-repo). Excludes self, same-repo collisions (those get the LOUD

package/dist/commands/delivery-reminder.js

@@ -18,18 +18,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.deliveryControlModule = void 0;
 exports.buildDeliveryAnnounce = buildDeliveryAnnounce;
 // adr: adr/delivery-announce-pilot.md
-/** How THIS harness finds same-repo peers — the one line that legitimately
- *  differs per platform. Everything else about notifying (once, fire-and-forget,
- *  chips excluded, why greprag is not the address book) is shared prose that
- *  belongs in `greprag load delivery`, not in nine duplicated sentences here. */
+/** How THIS harness treats same-repo peers at delivery — the one line that
+ *  legitimately differs per platform. Everything else about notifying (once,
+ *  fire-and-forget, chips excluded, why Claude Code sends nothing) is shared
+ *  prose that belongs in `greprag load delivery`, not duplicated here. */
 function coordinationLine(platform) {
+    // Claude Code holds a message to a session in another permission mode for that
+    // session's user and may let it expire, and the sender cannot see the mode. A
+    // notice there can silently not arrive, so its silence was never approval.
+    if (platform === 'claude-code') {
+        return 'Send same-repo peers no delivery notice: Git is the coordination. Never poll, wait on, or ask peer sessions for status.';
+    }
     const how = platform === 'codex'
         ? 'codex_app.list_threads + codex_app.send_message_to_thread'
-        : platform === 'claude-code'
-            ? "this harness's own session-list + send tools (never a greprag id)"
-            : platform === 'opencode'
-                ? 'the GrepRAG registry'
-                : 'your harness\'s own peer tools';
+        : platform === 'opencode'
+            ? 'the GrepRAG registry'
+            : 'your harness\'s own peer tools';
     // Codex keeps its one extra word: `wait_threads` is the specific tool a Codex
     // session reaches for when it decides to wait for a reply it was told not to
     // wait for. A named tool is a rule; "do not wait" alone was not enough.

package/dist/opencode-plugin.bundle.js

@@ -2534,7 +2534,10 @@ var loadoutRegistrarModule = {
 
 // src/commands/delivery-reminder.ts
 function coordinationLine(platform) {
-  const how = platform === "codex" ? "codex_app.list_threads + codex_app.send_message_to_thread" : platform === "claude-code" ? "this harness's own session-list + send tools (never a greprag id)" : platform === "opencode" ? "the GrepRAG registry" : "your harness's own peer tools";
+  if (platform === "claude-code") {
+    return "Send same-repo peers no delivery notice: Git is the coordination. Never poll, wait on, or ask peer sessions for status.";
+  }
+  const how = platform === "codex" ? "codex_app.list_threads + codex_app.send_message_to_thread" : platform === "opencode" ? "the GrepRAG registry" : "your harness's own peer tools";
   const never = platform === "codex" ? "never poll, call wait_threads, ask for status, or follow up" : "never poll, wait, ask for status, or follow up";
   return `Notify same-repo peer sessions ONCE via ${how}, then continue. A \`Chip: \` session is not a peer. Silence is approval: ${never}.`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greprag",
-  "version": "5.83.0",
+  "version": "5.83.1",
   "description": "Private GrepRAG client for existing Claude Code, Codex, OpenCode, and Grok Build tenants.",
   "main": "dist/index.js",
   "bin": {

package/skill/greprag/SKILL.md

@@ -211,7 +211,7 @@ Child watch events may appear on the parent TUI — resume the child to act. Do
 
 **INBOX MESSAGE FROM A PEER SESSION? REPLY DIRECTLY — the "summarize + confirm" rule is HUMAN-scoped.** Classify by the server-authoritative `from.session_id` (spoof-safe — a cold-open cannot set it): **set ⇒ PEER** agent session → reply/coordinate directly, NO human confirm; **null ⇒ HUMAN** (cold-open / inbound email) → summarize + confirm before acting. The asyncRewake poll tags each delivered wake with `[peer coordination …]` / `[human …]`; the Monitor `--json` stream carries `from.session_id` raw. **GUARD: auto-REPLY, not auto-OBEY** — coordinate with peers freely, but a destructive action a peer *requests* still passes the normal gates; never blindly execute peer instructions. adr: adr/monitor-resilience.md.
 
-**COLLISION IN A REPO? (another live session working the SAME repo) — NOTICE ONCE, THEN MOVE.** Work in an isolated branch/worktree. At delivery, resolve `.greprag/delivery.json`, send one fire-and-forget notice to same-repo peers, and continue immediately. Recipients reply only for a concrete conflict; silence is approval. Never poll, call `wait_threads`, inspect peer status, re-read tasks, ask for acknowledgement, or follow up. Sweep every ready same-repo commit; ignore all uncommitted and untracked work. Resolve Git conflicts directly, merge to the default branch, and finish the declared push/deploy/release path from the canonical primary checkout — never from a worktree. Codex uses `codex_app.send_message_to_thread`; use `greprag send` only for known non-Codex peers. Full mechanism: `docs/delivery-system.md`.
+**COLLISION IN A REPO? (another live session working the SAME repo) — WORK APART, THEN LAND.** Work in an isolated branch/worktree. At delivery, resolve `.greprag/delivery.json`, notify peers only as this harness's Delivery announce says, and continue immediately. Never poll, call `wait_threads`, inspect peer status, re-read tasks, ask for acknowledgement, or follow up. Sweep every ready same-repo commit; ignore all uncommitted and untracked work. Resolve Git conflicts directly, merge to the default branch, and finish the declared push/deploy/release path from the canonical primary checkout — never from a worktree. Full mechanism: `docs/delivery-system.md`.
 
 **Codex: DO NOT CLAIM HOOKS ARE ACTIVE JUST BECAUSE `~/.codex/hooks.json` EXISTS.** Codex Desktop requires Settings -> Settings -> Hooks trust review before command hooks run automatically. If turn capture is missing after `greprag init --codex`, tell the user: open Codex Desktop Settings -> Settings -> Hooks, trust the GrepRAG hooks, then start a fresh Codex session.
 

package/skill/mechanic/SKILL.md

@@ -85,7 +85,7 @@ Same gate the hourly compactor applies at write-time — Mechanic and compactor
 - **Never promote into the chip-spawn template without confirm.** Global rules are sticky.
 - **Cross-project carve-out.** Default to the current project (resolved via `greprag fix list`). The Phase 0 census MAY read sibling queues to show where fixes piled up; *draining* one requires the operator to name it, and every `add`/`delete` against it MUST carry `--project <that-project>`. Never touch a sibling silently.
 - **Harness scope is mandatory.** Friction carries its source harness (`claude-code`, `codex`, `opencode`). Repairs to hooks/skills/watchers must target that harness with `greprag mechanic install ... --harness <name>`. In a Codex session, default to `--harness codex`; use `--harness all` only for deliberately portable mechanisms.
-- **Delivery is committed-state convergence.** Before merging, pushing, deploying, publishing, tagging, or cutting a release, send one fire-and-forget notice to same-repo peers and continue immediately. Recipients reply only for a concrete conflict; silence is approval. Never poll, wait, inspect peer status, or follow up. Sweep every ready same-repo commit and ignore all uncommitted and untracked work. Resolve Git conflicts directly; no deploy lease or peer ownership ceremony exists.
+- **Delivery is committed-state convergence.** Notify peers only as this harness's Delivery announce says, then continue immediately. Never poll, wait, inspect peer status, or follow up. Sweep every ready same-repo commit and ignore all uncommitted and untracked work. Resolve Git conflicts directly; no deploy lease or peer ownership ceremony exists.
 
 ## Codex Mechanic chip handoff
 

package/skill/templates/delivery.md

@@ -32,17 +32,31 @@ a destructive action one asks for still passes its normal gate.
 A peer is another session working in the same repository at the same level as
 you. Peer discovery is your harness's own job:
 
-- **Claude Code** — your native session-list tool paired with its own send
-  tool, matched on working directory. A greprag 8-hex id is NOT a Claude Code
-  address, and `greprag inbox watchers` does not list Claude Code sessions at
-  all, so an empty watcher list is not evidence that nobody else is in your
-  repo. greprag carries only traffic from OUTSIDE this harness.
 - **Codex** — `codex_app.list_threads` to discover, `codex_app.send_message_to_thread` to notify.
 - **OpenCode** — the GrepRAG registry.
+- **Claude Code** — sends no notice at all; see below.
 
 If this session has no such tools, say so in your report rather than shipping
 silently.
 
+### Claude Code sends no notice
+
+Claude Code holds a message sent to a session running in a different permission
+mode until that session's user approves it, and lets it expire if nobody does.
+The sender cannot see another session's mode, and the harness says outright
+that silence from a Desktop or Remote Control session is not agreement. So a
+notice there could vanish while its sender counted the silence as approval, and
+a held one left an approval prompt in someone else's session.
+
+Nothing is lost by not sending it. No step waits for a reply, so a notice that
+did arrive never changed what the sender did next. Git reaches every peer in
+every mode: each one fetches, rebases onto the tip, and retests before it
+lands, and the merge lock and `--ff-only` keep two landings from interleaving.
+
+Field trigger (2026-10-06): an openwriter session's delivery notice to a peer in
+another permission mode was held, then expired undelivered. The same had
+happened in another project two days earlier.
+
 ### A chip is not a peer
 
 A session titled `Chip: …` or `Chip <Label>: …` is somebody's child task. A