@lifeaitools/rdc-skills 0.28.0 → 0.30.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight unattended builds with work-item tracking and TDD enforcement.",
   "author": {
     "name": "LIFEAI",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "RDC typed-agent dispatch skill suite for Claude Code - plan, build, review, overnight builds",
   "keywords": [
     "claude-code",

package/skills/collab/COLLABORATOR.md

@@ -41,6 +41,12 @@ not an evasion.
    It should not re-dispatch on top of a call you are still working.
 6. **Escalation, not blame,** when you disagree. A stated disagreement with
    evidence is a valid terminal state.
+7. **A model chosen for the work,** named in the dispatch — not whatever the
+   engine happened to be configured with. If you are asked to settle an
+   architecture question or verify a claim adversarially and you are running on
+   a tier below that, say so in your reply rather than answering anyway. A
+   confident answer from the wrong tier is the expensive failure here: it reads
+   exactly like a correct one and nothing downstream catches it.
 
 ---
 
@@ -65,6 +71,54 @@ write may not be.**
 
 ## What you owe BACK — your responsibilities
 
+### 0. Answer the `status` handshake honestly, by PROBING.
+
+Before the real conversation starts you will be asked for `COLLAB-STATUS/1`.
+Emit every field. **Capability fields must be probed, not assumed** — actually
+attempt the seam and report the literal result.
+
+```
+COLLAB-STATUS/1
+agent:            <you>
+engine_version:   <version>
+skill_version:    <rdc-skills version>
+
+--- managed identity (all 8; an absent field IS the diagnosis) ---
+lane:                     <lane | NONE>
+role:                     worker | supervisor | NONE
+repo_identity:            <repo>
+owner_pid:                <pid | NONE>
+owner_start_fingerprint:  <present | ABSENT>
+session_id:               <id | NONE>
+lease_epoch:              <epoch | NONE>
+owner_token:              present | ABSENT      ← NEVER the value
+
+--- capability (PROBED — name the probe) ---
+can_write:    yes | no | unknown   probe: <what you actually ran>
+can_commit:   yes | no | unknown   probe: <…>
+can_push:     yes | no | unknown   probe: <…>
+
+--- position ---
+cwd: <path>   branch: <branch>   head: <sha>   dirty: <n tracked files>
+ahead/behind: <n>/<n> vs <named upstream>
+
+--- services ---
+codeflow: <status>   clauth: <status>   work_items: reachable | no
+```
+
+**Rules that make this worth asking for:**
+
+- **Never emit the `owner_token` value.** `present`/`ABSENT` only — this output
+  lands in transcripts and logs.
+- **`unknown` is an honest answer. `yes` without a probe is not.** If you could
+  not test the seam, say `unknown` and name why. A capability you assumed and
+  cannot demonstrate is precisely the claim this protocol exists to eliminate.
+- **Report the lane you are ACTUALLY in**, not the one you were asked to be in.
+  If they differ, your session identity is poisoned — say so in the same reply.
+  That one line saves the initiator an entire wasted round.
+- A missing identity field is not an embarrassment to smooth over. It is the
+  most useful thing you can tell the initiator.
+
 ### 1. Answer in the required format. Nothing outside it.
 
 If the dispatch gives you a contract, use it verbatim. Prose around the blocks

package/skills/collab/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: rdc:collab
-description: "Usage `rdc:collab <collaborator> [inbound] <topic>` — Structured agent-to-agent CONVERSATION with Codex, a local LLM, a Claude agent, or a claude.ai session. Converges on a decision and never writes to the repo — work that needs writing becomes a work item for rdc:build. Every dispatch carries a response contract."
+description: "Usage `rdc:collab <collaborator> [inbound] <topic>` — Structured agent-to-agent CONVERSATION with Codex, a local LLM, a Claude agent, or a claude.ai session. Converges on a decision and never writes to the repo — work that needs writing becomes a work item for rdc:build. Run `rdc:collab status <peer>` first — both sides emit probed capability state. Every dispatch carries a response contract."
 ---
 
 > **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
@@ -116,8 +116,11 @@ diagnosis ladder in order and stop at the first hit:
 2. **Did it exit, and with what?** A non-zero exit or exit 143 (killed) is a
    result, not silence. Read it.
 3. **Was it guard-blocked?** Grep the output for a `deny`/`Blocked` line. The
-   `CODEX MANAGED LANE` block is the common one and is a *dispatch* defect
-   (wrong `-C`), not a peer failure — fix and re-dispatch once.
+   `CODEX MANAGED LANE` block is the common one and is a *dispatch* defect, not a
+   peer failure. **It is not fixed by `-C`** — the session's identity was recorded
+   at creation and `resume` replays it, so a mis-started session is poisoned for
+   life. Start a **new** session in the right lane. Had `status` run first
+   (Step 0.5), this would have been visible before any content was sent.
 4. **Is the session still addressable?** A stale `resume <session-id>`, a stopped
    chitchat session, or a dead local-LLM endpoint all present as silence.
 5. **Did it answer somewhere you are not reading?** A peer that cannot write its
@@ -134,8 +137,9 @@ outliving its dispatch is noise, and noise is how a real stall gets ignored.
 ## Step 0 — Parse arguments
 
 ```
-rdc:collab <collaborator> [mode] <topic…>
-rdc:collab --session <id>          ← legacy form, implies `claude-ai listen`
+rdc:collab status <collaborator>          ← handshake; run BEFORE round 1
+rdc:collab <collaborator> [inbound] <topic…>
+rdc:collab --session <id>                 ← legacy form, implies `claude-ai inbound`
 ```
 
 - No collaborator → list active chitchat sessions and available engines, then stop.
@@ -146,6 +150,73 @@ rdc:collab --session <id>          ← legacy form, implies `claude-ai listen`
 
 ---
 
+## Step 0.5 — `status` handshake (run BEFORE round 1)
+
+`rdc:collab status <collaborator>` — both sides emit their state. **This is a
+precondition, not a debugging command.** Reaching for it after a failure is
+already too late; the point is to never dispatch into a session that cannot
+deliver.
+
+**The probe rule — the whole value of this step.** Every capability field is
+**PROBED, never asserted.** A peer that *reports* `can_write: yes` from an
+assumption has produced another unverified capability claim, which is the defect
+class this entire protocol exists to remove. `-C` "should" have set lane identity
+too. Probe the seam, report the literal result, and if you cannot probe, say
+`unknown` — never `yes`.
+
+### `COLLAB-STATUS/1` payload
+
+```
+COLLAB-STATUS/1
+agent:            codex | claude-code | claude-ai | local-llm
+engine_version:   <version>
+skill_version:    <rdc-skills version>
+
+--- managed identity (the 8 fields; absent ones are the diagnosis) ---
+lane:                     <lane | NONE>
+role:                     worker | supervisor | NONE
+repo_identity:            <repo>
+owner_pid:                <pid | NONE>
+owner_start_fingerprint:  <present | ABSENT>
+session_id:               <id | NONE>
+lease_epoch:              <epoch | NONE>
+owner_token:              present | ABSENT      ← NEVER the value
+
+--- capability (PROBED — state the probe used) ---
+can_write:    yes | no | unknown   probe: <what you actually ran>
+can_commit:   yes | no | unknown   probe: <…>
+can_push:     yes | no | unknown   probe: <…>
+
+--- position ---
+cwd:      <path>
+branch:   <branch>
+head:     <sha>
+dirty:    <n tracked files>
+ahead/behind: <n>/<n> vs <named upstream>
+
+--- services ---
+codeflow: <status>   clauth: <status>   work_items: reachable | no
+```
+
+**`owner_token` reports `present`/`ABSENT` only. Never emit the value** — status
+output lands in transcripts and logs.
+
+### How the initiator reads it
+
+| Signal | Meaning | Action |
+|---|---|---|
+| `lane: NONE` or missing identity fields | No managed identity was ever minted | Conversation only. Do not name this peer as writer. |
+| `can_write: no` | Structurally read-only right now | Fine for collab. Name someone else to land the outcome. |
+| `can_write: unknown` | It could not probe | Treat as `no` until proven. Never as `yes`. |
+| `lane` ≠ the lane you dispatched to | **Poisoned session** — identity is recorded at creation and `resume` replays it | Start a NEW session. `-C` will not repair it. |
+| `dirty` > 0 on a peer you are about to name as writer | Pre-existing uncommitted work | Surface it before it gets swept into your commit |
+
+**Mismatch between what you dispatched and what `status` reports is the single
+highest-value signal in this protocol.** It is exactly the failure that cost a
+full negotiation on 2026-08-14, and it is visible in one line here.
+
+---
+
 ## Step 1 — Collaborator matrix
 
 Resolve the transport BEFORE composing the message. Getting this wrong is the
@@ -182,6 +253,42 @@ file:///C:/Dev/lifeai-env/pool/codex-topology.mjs
 **Dispatch is long-running.** Run engine dispatch as a **background task**, not
 behind a `timeout` guess. A truncated call looks like a failure and is not one.
 
+### Step 1b — Pick the model for the work
+
+**If the invocation names a model, use it. Otherwise choose one — do not silently
+take the engine default.** The default is whatever that engine was last
+configured with, which has no relationship to the task in front of it, and a
+reasoning-heavy negotiation run on a small model produces confident agreement
+that does not survive contact with the code.
+
+Model is a **per-invocation** flag on both engines, so it applies to a resumed
+conversation exactly as it does to a new one — a long-running collab lane can
+change model between sittings without starting over:
+
+| Engine | Flag |
+|---|---|
+| `codex` | `codex -m <model>` · with resume: `codex resume <id> -m <model>` |
+| `claude` | `claude --model <model>` |
+| interactive collab lane | `collab-launch.ps1 -Name <lane> -Model <model>` |
+
+Choose by the KIND of work, not by the size of the diff:
+
+| Work | Model tier | Why |
+|---|---|---|
+| Negotiating a design, architecture review, adversarial verification, root-causing a defect that resisted one fix | **most capable** (Opus-class / `gpt-5`-class) | The output is a decision that other work is built on. A wrong one is not caught by tests. |
+| Implementing an agreed plan, mechanical refactor, test authoring, doc sweep | **mid tier** (Sonnet-class) | The shape is already decided; the cost of a retry is one run. |
+| Formatting, lint fixes, transcription, extracting fields from output | **fast/cheap** (Haiku-class) | No judgment involved. |
+
+Two rules that override the table:
+
+1. **Escalate on a repeat.** If a task has already failed once — a fix that did
+   not hold, a round that did not shrink the open set — the next attempt goes up
+   a tier, not sideways. Re-running the same tier on the same problem is how a
+   loop starts.
+2. **State the choice in the dispatch.** One line: *"running this on `<model>`
+   because it is an architecture decision."* A model choice nobody can see is a
+   model choice nobody can correct.
+
 ---
 
 ## Step 2 — Compose the response contract (mandatory)
@@ -196,11 +303,21 @@ repo mid-conversation, which is the v0.27.0 defect this version removes.
 **The contract — one block per open point:**
 
 ```
-POINT <n>: AGREE | AGREE-WITH-AMENDMENT | DISAGREE
+POINT <n>: AGREE | AGREE-WITH-AMENDMENT | DISAGREE | UNKNOWN | DEFER
 EDIT: <the exact section and change that SHOULD be made, or NONE — describe it, do not make it>
-REASON: <one sentence — only if AMENDMENT or DISAGREE>
+REASON: <one sentence — required for AMENDMENT, DISAGREE, UNKNOWN and DEFER>
 ```
 
+`UNKNOWN` and `DEFER` are first-class answers, not failures. A three-value
+contract forces a peer that lacks the evidence to invent a position, and an
+invented position is indistinguishable from a settled one in the next round —
+which is how a negotiation converges on something nobody actually checked. Adopted
+from Codex, 2026-08-15: *"binary agreement forces invented certainty."*
+
+**Every handshake carries `AS_OF` and `PROBE_STATE`** — when the peer last
+observed the thing it is describing, and whether that observation was live,
+cached, or absent. A claim with no as-of is a claim about an unknown moment.
+
 **When the point is a factual question rather than a proposal**, the peer answers
 with findings — still text, still no repo mutation:
 
@@ -212,13 +329,54 @@ CONFIDENCE: VERIFIED | INFERRED | UNKNOWN
 
 Rules that make the contract hold:
 
-1. **State the format before the content.** Contract first, then the points.
+0. **Write like the peer, not like a memo.** An engine peer answers in dense,
+   structured blocks; address it the same way. Contract, numbered points, the
+   facts each point turns on — no preamble, no restating what was settled last
+   round in prose, no explaining your reasoning for a position the EDIT line
+   already states. Every sentence that is not a point, a constraint, or a fact
+   the peer needs is padding the peer must parse before it can answer. Prose
+   framing is for the human reading the transcript afterward, and it belongs in
+   the summary you write for them — not in the dispatch.
+1. **Name what to read, by path, before the points.** A peer does not go looking
+   on its own — it answers from what is in front of it, exactly like you do. A
+   dispatch that says "review the remediation plan" gets an answer about the peer's
+   memory of a plan; a dispatch that says `read
+   .rdc/areas/infra/fleet-throughput/plans/fleet-throughput-remediation.md §T1–T6
+   and pool/codex-topology.mjs sameOwner()` gets an answer about the code. List
+   the files, the sections, and the one thing to look for in each. If the peer
+   cannot reach a path, that is a `BLOCKED` you want stated early rather than an
+   answer quietly built on something else.
+
+   **A path beats a paraphrase. Never restate a document you can point at.** Both
+   engines share this filesystem, so pasting a plan into the dispatch buys
+   nothing and costs three ways: the peer answers your summary instead of the
+   source, your summary is stale the moment the file changes, and the context it
+   spends re-reading your prose is context it does not spend on the question. Link
+   the document, name the section, ask the question. The only text worth inlining
+   is what does NOT exist in a file yet — the open points themselves.
+2. **State the format before the content.** Contract first, then the points.
 2. **Say what NOT to produce** when the peer has a known default — e.g. *"do not
    write a lesson; this is a Decision and belongs in the plan."*
 3. **Number the points.** Unnumbered points get answered in aggregate.
 4. **Name the single writer before round 1** (see Step 4).
 5. **Ask for `BLOCKED` explicitly.** Without it, a peer that cannot act reports
    success or silence.
+6. **Mark a conversation-only collab as such, in the dispatch and in your own
+   turn.** A collab whose declared deliverable IS the reply produces no
+   repository artifact by design (Step 2's whole premise: the peer describes the
+   edit, it does not make it). An end-of-turn gate that demands a file, a commit,
+   or a lesson from such a turn is asking the protocol to violate itself, and the
+   peer's only honest answer becomes a repeated `BLOCKED` — which is exactly what
+   happened on 2026-08-15: a Codex peer returned a complete, contract-shaped,
+   four-point answer and then reported `BLOCKED: this conversation-only collab
+   cannot produce repository artifacts` twice more, because the gate would not
+   accept the reply as the deliverable.
+
+   State the deliverable explicitly — *"the deliverable of this turn is the reply
+   itself; no repository artifact is expected"* — so the completion gate has a
+   declared reason rather than an absence to interpret. The Decision that comes
+   OUT of the collab still lands in a governing document (Step 5); it is the
+   negotiation turns themselves that are conversation-only.
 
 ---
 
@@ -259,6 +417,12 @@ dispatch.
 > Two active writers on one surface is forbidden — the same rule the fleet plans
 > state as *"never run two active writers for one effect."*
 
+**Scope ownership to a named effect or artifact, never to an agent in general** —
+"Claude owns `fleet-throughput-remediation.md`", not "Claude is the writer".
+Transfer is explicit and acknowledged; **silence never transfers ownership**. A
+peer that has gone quiet is unobservable, not resigned, and treating those as the
+same thing is how two writers end up on one file.
+
 If the named writer turns out to be **structurally blocked** (wrong lane, no
 credentials, read-only mount), ownership transfers to the other agent *for that
 artifact only*, recorded in the change itself with attribution. A blocked writer