/talk-to

name: talk-to
description: Talk to another Oracle agent via contacts + threads. Use when user says "talk to", "message", "chat with", or wants to communicate with another agent (e.g. "talk to pulse", "message neo"). Do NOT trigger for OracleNet social feed (use /oraclenet), skill management (use /oracle), or family registry (use /oracle-family-scan).
argument-hint: "<agent-name> [message] [--maw | --thread | --inbox]"
hidden: true
metadata:
  internal: true

/talk-to - Agent Messaging

Send messages to agents via Oracle threads. Each agent has a persistent channel thread.

> **Messaging consolidation (2026-07-06):** /hey, /contacts, /mailbox, and /inbox were > archived to the zombie tier — this skill is the one messaging verb now. For real-time > tmux pings use `maw hey` directly (or `--maw` here). Archived skills remain installable > via `arra install -s <name>`.

Usage

/talk-to arthur "What's your status?"          # one-shot message
/talk-to arthur --new "Hey, starting fresh"    # skip lookup, create new thread
/talk-to arthur loop ask about their work      # autonomous conversation
/talk-to #42 "follow up on this"               # post to thread by ID
/talk-to --list                                # show channels
/talk-to arthur --maw "quick ping"             # force maw transport (real-time tmux)
/talk-to arthur --thread "async question"      # force MCP thread transport
/talk-to arthur --inbox "offline message"      # force inbox transport (file write)

Mode 0: No arguments

If ARGUMENTS is empty, show usage help then run --list.

Step 0: Contacts Lookup

**Always read contacts first.** This is the source of truth for agent routing.

date "+🕐 %H:%M %Z (%A %d %B %Y)"
CONTACTS="$(pwd)/ψ/contacts.json"
if [ ! -f "$CONTACTS" ]; then
  # Fallback path
  CONTACTS="$(pwd)/.oracle/contacts.json"
fi

if [ -f "$CONTACTS" ]; then
  MAW=$(jq -r ".contacts.\"$AGENT\".maw // empty" "$CONTACTS")
  INBOX=$(jq -r ".contacts.\"$AGENT\".inbox // empty" "$CONTACTS")
  THREAD=$(jq -r ".contacts.\"$AGENT\".thread // empty" "$CONTACTS")
  REPO=$(jq -r ".contacts.\"$AGENT\".repo // empty" "$CONTACTS")
  NOTES=$(jq -r ".contacts.\"$AGENT\".notes // empty" "$CONTACTS")
  FOUND_IN_CONTACTS=true
else
  FOUND_IN_CONTACTS=false
fi

**If agent not found in contacts AND not found in maw ls**:

I don't know "{agent}".

  /contacts add {agent}    — register transport info
  /talk-to {agent} --thread "message"  — try MCP thread anyway

Offer `/contacts add` first. If user insists, fall through to MCP thread.

---

Transport Selection

| Flag | Transport | Best For | |------|-----------|----------| | (none) | **auto** — detect best | Default | | `--maw` | `maw hey` (tmux sendkeys) | Real-time, local fleet, low latency | | `--thread` | MCP `oracle_thread` | Async, persistent, cross-machine | | `--inbox` | File write to `ψ/inbox/` | Offline, no maw/MCP needed |

**Auto-detect logic** (when no flag): 1. Check `ψ/contacts.json` → has `maw` field? → use `maw hey` 2. No contacts? → `maw ls 2>/dev/null | grep -q "{agent}"` fallback → use `maw hey` 3. Neither? → use MCP thread (async, persistent)

# Auto-detect: contacts-first, maw ls fallback
if [ -n "$MAW" ]; then
  echo "USE_MAW (from contacts: $MAW)"
elif maw ls 2>/dev/null | grep -q "{agent}"; then
  echo "USE_MAW (from maw ls)"
else
  echo "USE_THREAD"
fi

Replying to a message another oracle sent you (#434)

A ping arrives in your context looking like `[m5:digger] …`. The reflex is to answer in your own transcript — but that text goes to Nat, not to digger, who is sitting in a different pane waiting. Reply with `maw hey` or the conversation is one-sided and nobody notices for hours.

maw hey <their-oracle-name> 'your reply'     # name, not a pane id

**Never reply to a pane id.** `maw peek %3001` works, so it is tempting to paste that same `%3001` into `maw hey` — it hard-errors (`bare target '%3001' not found locally`). Pane ids are a peek-only handle. `maw ls -v` is the source of truth for targets; a bare `maw ls | grep` finds the row but not the addressable name, which is why the auto-detect above should be treated as a hint, not an answer:

maw ls -v | grep -i <name>      # resolves the real target
maw hey <target> ping --dry-run # confirm it resolves BEFORE sending

`--dry-run` is the cheap check. It costs nothing and catches a wrong target before the message goes somewhere confusing.

When using `--maw`: 1. Compose message from intent 2. Use contacts maw name if available: `maw hey {MAW or agent-oracle} '{message}'` 3. Optionally `maw peek {agent}` to check response 4. Confirm: `Sent via maw to {agent}`

When using `--inbox`: 1. Compose message from intent 2. Check contacts for inbox path — if empty, error: `No inbox path for {agent}. Run /contacts show {agent}` 3. Write message file:

   SELF="$(basename $(pwd) | sed 's/-oracle$//')"
   echo "$MESSAGE" > "$INBOX/$(date +%Y%m%d_%H%M)_from_${SELF}.md"

4. Confirm: `Dropped to {agent}'s inbox`

When using `--thread` (or auto-detected thread): Fall through to Mode 3 (one-shot) below.

Routing

| Pattern | Use | |---------|-----| | `channel:{agent}` | Persistent per-agent channel | | `topic:{agent}:{slug}` | Topic-specific thread (with `--topic`) | | `#{id}` | Direct thread reference by ID |

Mode 1: --list

1. `arra_threads()` (no status filter) 2. Filter titles starting with `channel:` or `topic:`, exclude `closed` 3. Display: `channel:arthur (#42) pending — 12 msgs`

Mode 2: --new (fast create)

Skip lookup. One MCP call.

1. Compose message from intent 2. `arra_thread({ title: "channel:{agent}", message, role: "human" })` 3. **Notify**: `Bash maw hey {MAW or agent-oracle} 'Thread #{id} from {self}: {preview}'`

• If `maw hey` fails → warn only, don't error (thread already sent)

4. Confirm: `Created channel:{agent} (thread #{id})`

Mode 3: One-shot (default)

1. Compose message from intent 2. I