truematch-plugin 0.1.6 → 0.1.8

package/dist/index.d.ts

@@ -4,6 +4,7 @@
  *
  * Usage:
  *   truematch setup [--contact-type email|discord|telegram|whatsapp|imessage] [--contact-value <val>]
+ *   truematch heartbeat
  *   truematch status [--relays]
  *   truematch observe --show | --update | --write '<json>'
  *   truematch preferences --show | --set '<json>'

package/dist/index.js

@@ -4,6 +4,7 @@
  *
  * Usage:
  *   truematch setup [--contact-type email|discord|telegram|whatsapp|imessage] [--contact-value <val>]
+ *   truematch heartbeat
  *   truematch status [--relays]
  *   truematch observe --show | --update | --write '<json>'
  *   truematch preferences --show | --set '<json>'
@@ -18,7 +19,7 @@
 import { parseArgs } from "node:util";
 import { getOrCreateIdentity, loadIdentity, ensureDir } from "./identity.js";
 import { register, deregister, loadRegistration, listAgents, } from "./registry.js";
-import { loadObservation, saveObservation, emptyObservation, eligibilityReport, isEligible, isStale, } from "./observation.js";
+import { loadObservation, saveObservation, emptyObservation, eligibilityReport, isEligible, isMinimumViable, isStale, } from "./observation.js";
 import { loadThread, listActiveThreads, initiateNegotiation, receiveMessage, sendMessage, proposeMatch, declineMatch, expireStaleThreads, saveThread, } from "./negotiation.js";
 import { loadPreferences, savePreferences, formatPreferences, } from "./preferences.js";
 import { checkRelayConnectivity, subscribeToMessages, DEFAULT_RELAYS, } from "./nostr.js";
@@ -40,6 +41,7 @@ const { values: args, positionals } = parseArgs({
         send: { type: "string" },
         receive: { type: "string" },
         peer: { type: "string" },
+        type: { type: "string" },
         propose: { type: "boolean" },
         decline: { type: "boolean" },
         messages: { type: "boolean" },
@@ -61,6 +63,9 @@ async function main() {
         case "setup":
             await cmdSetup();
             break;
+        case "heartbeat":
+            await cmdHeartbeat();
+            break;
         case "status":
             await cmdStatus();
             break;
@@ -125,6 +130,25 @@ To complete setup, provide your contact channel:
 
 Next: run 'truematch observe --update' after a few conversations to build your personality model.`);
 }
+// ── heartbeat ─────────────────────────────────────────────────────────────────
+// Re-registers with stored credentials to refresh lastSeen in the registry.
+// Called by the auto-poll cron so the agent stays visible in the matching pool
+// without the user having to run setup again.
+async function cmdHeartbeat() {
+    const identity = await loadIdentity();
+    if (!identity) {
+        console.error("Not set up. Run: truematch setup");
+        process.exit(1);
+    }
+    const reg = await loadRegistration();
+    if (!reg) {
+        console.error("Not registered. Run: truematch setup");
+        process.exit(1);
+    }
+    const prefs = await loadPreferences();
+    await register(identity, reg.card_url, reg.contact_channel, prefs.location, prefs.distance_radius_km);
+    console.log(`Heartbeat sent. pubkey: ${identity.npub.slice(0, 16)}...`);
+}
 // ── status ────────────────────────────────────────────────────────────────────
 async function cmdStatus() {
     const identity = await loadIdentity();
@@ -141,7 +165,9 @@ async function cmdStatus() {
     }
     else {
         console.log(`\nObservation eligibility:\n${eligibilityReport(obs)}`);
-        console.log(`\nPool eligible: ${isEligible(obs) ? "YES" : "NO"}`);
+        const eligible = isEligible(obs);
+        const mve = isMinimumViable(obs);
+        console.log(`\nPool eligible: ${eligible ? "YES (full)" : mve ? "YES (MVE — T1+T2 only)" : "NO"}`);
         if (isStale(obs)) {
             console.log("⚠ Manifest is stale — run 'truematch observe --update'");
         }
@@ -323,6 +349,10 @@ async function cmdMatch() {
     // Registers an inbound message and saves the thread state on the receiving side.
     // Use this when poll.js outputs a message that has no local thread yet.
     if (args["receive"] !== undefined) {
+        if (!identity) {
+            console.error("Not set up. Run: truematch setup");
+            process.exit(1);
+        }
         const content = args["receive"];
         const thread_id = args["thread"];
         const peerNpub = args["peer"];
@@ -330,16 +360,31 @@ async function cmdMatch() {
             console.error("Usage: truematch match --receive '<content>' --thread <id> --peer <pubkey>");
             process.exit(1);
         }
-        const msgType = args["type"] ?? "negotiation";
+        const rawType = args["type"];
+        if (rawType !== undefined &&
+            rawType !== "negotiation" &&
+            rawType !== "match_propose" &&
+            rawType !== "end") {
+            console.error(`Invalid --type "${rawType}". Must be: negotiation, match_propose, or end`);
+            process.exit(1);
+        }
+        const msgType = rawType ?? "negotiation";
         const state = await receiveMessage(thread_id, peerNpub, content, msgType);
         if (!state) {
-            console.error(`Could not register inbound message (thread rejected — invalid id or DoS cap reached)`);
+            console.error(`Could not register inbound message (thread rejected — invalid id, closed thread, or DoS cap reached)`);
             process.exit(1);
         }
         console.log(`Message registered. Thread ${thread_id.slice(0, 8)}... — round ${state.round_count} — status: ${state.status}`);
         if (state.status === "matched") {
             if (state.match_narrative) {
-                writePendingNotificationIfMatched(state.thread_id, state.peer_pubkey, state.match_narrative);
+                try {
+                    writePendingNotificationIfMatched(state.thread_id, state.peer_pubkey, state.match_narrative);
+                }
+                catch (err) {
+                    process.stderr.write(`Warning: notification write failed — match IS confirmed, but pending_notification.json was not written. ` +
+                        `Run 'truematch match --status --thread ${state.thread_id}' to view the match.\n` +
+                        `Error: ${err instanceof Error ? err.message : String(err)}\n`);
+                }
             }
             console.log("MATCH CONFIRMED (double-lock cleared).");
         }
@@ -422,7 +467,7 @@ async function cmdMatch() {
             process.exit(1);
         }
         const obs = await loadObservation();
-        if (!obs || !isEligible(obs)) {
+        if (!obs || (!isEligible(obs) && !isMinimumViable(obs))) {
             console.error("Observation not yet eligible for matching. Run: truematch status");
             process.exit(1);
         }
@@ -458,11 +503,18 @@ async function cmdMatch() {
             !activePeers.has(a.pubkey) &&
             new Date(a.lastSeen).getTime() > twoHoursAgo);
         if (candidates.length === 0) {
-            if (agents.filter((a) => a.pubkey !== identity.npub).length === 0) {
+            const othersInPool = agents.filter((a) => a.pubkey !== identity.npub);
+            if (othersInPool.length === 0) {
                 console.log("No other agents in the pool yet. Check back later.");
             }
             else {
-                console.log("Already negotiating with all available agents. Check back later.");
+                const recentOthers = othersInPool.filter((a) => new Date(a.lastSeen).getTime() > twoHoursAgo);
+                if (recentOthers.length === 0) {
+                    console.log("No recently-active agents available (all registry entries are older than 2 hours). Check back later.");
+                }
+                else {
+                    console.log("Already negotiating with all available agents. Check back later.");
+                }
             }
             return;
         }

package/dist/negotiation.js

@@ -106,6 +106,11 @@ export async function receiveMessage(thread_id, peerNpub, content, type) {
     const now = new Date().toISOString();
     let state = await loadThread(thread_id);
     if (!state) {
+        // A brand-new thread with type === "end" is a no-op: no legitimate protocol
+        // reason to open and immediately close a thread. Reject silently to avoid
+        // leaking thread existence and prevent disk-write DoS from "end" floods.
+        if (type === "end")
+            return null;
         // First message from this peer on this thread_id.
         // Guard against DoS: count existing active threads from this peer.
         const existing = await listActiveThreads();
@@ -131,6 +136,10 @@ export async function receiveMessage(thread_id, peerNpub, content, type) {
         // leaking thread existence or peer identity to the caller
         return null;
     }
+    else if (state.status !== "in_progress") {
+        // Reject messages on closed threads (declined, matched, expired)
+        return null;
+    }
     state.last_activity = now;
     // round_count tracks only our outgoing messages — do not increment on receive
     const incoming = {
@@ -220,6 +229,9 @@ export async function declineMatch(nsec, thread_id, relays) {
     const state = await loadThread(thread_id);
     if (!state)
         throw new Error(`Thread ${thread_id} not found`);
+    if (state.status !== "in_progress") {
+        throw new Error(`Thread ${thread_id} is not in progress (status: ${state.status})`);
+    }
     await sendEnd(nsec, state.peer_pubkey, thread_id, relays);
     state.status = "declined";
     state.last_activity = new Date().toISOString();

package/dist/observation.d.ts

@@ -14,6 +14,7 @@ export declare const ELIGIBILITY_FRESHNESS_HOURS = 72;
 export declare function loadObservation(): Promise<ObservationSummary | null>;
 export declare function saveObservation(obs: ObservationSummary): Promise<void>;
 export declare function isEligible(obs: ObservationSummary): boolean;
+export declare function isMinimumViable(obs: ObservationSummary): boolean;
 export declare function isStale(obs: ObservationSummary): boolean;
 export declare function emptyObservation(): ObservationSummary;
 export declare function eligibilityReport(obs: ObservationSummary): string;

package/dist/observation.js

@@ -1,8 +1,10 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { TRUEMATCH_DIR } from "./identity.js";
-const OBSERVATION_FILE = join(TRUEMATCH_DIR, "observation.json");
+import { getTrueMatchDir } from "./identity.js";
+function getObservationFile() {
+    return join(getTrueMatchDir(), "observation.json");
+}
 // Global minimums — cross-session sanity check
 const GLOBAL_MIN_CONVERSATIONS = 2;
 const GLOBAL_MIN_DAYS = 2;
@@ -27,9 +29,9 @@ export const DIMENSION_FLOORS = {
 // Bridge should trigger re-synthesis if stale.
 export const ELIGIBILITY_FRESHNESS_HOURS = 72;
 export async function loadObservation() {
-    if (!existsSync(OBSERVATION_FILE))
+    if (!existsSync(getObservationFile()))
         return null;
-    const raw = await readFile(OBSERVATION_FILE, "utf8");
+    const raw = await readFile(getObservationFile(), "utf8");
     return JSON.parse(raw);
 }
 export async function saveObservation(obs) {
@@ -40,7 +42,7 @@ export async function saveObservation(obs) {
         eligibility_computed_at: now,
         matching_eligible: isEligible(obs),
     };
-    await writeFile(OBSERVATION_FILE, JSON.stringify(updated, null, 2), "utf8");
+    await writeFile(getObservationFile(), JSON.stringify(updated, null, 2), "utf8");
 }
 export function isEligible(obs) {
     if (obs.conversation_count < GLOBAL_MIN_CONVERSATIONS)
@@ -64,6 +66,17 @@ export function isEligible(obs) {
         obs.interdependence_model.confidence >=
             DIMENSION_FLOORS.interdependence_model);
 }
+// Minimum Viable Evidence (MVE) for a quick match proposal — 4 core dimensions only.
+// Agents can propose if MVE is met even when the full isEligible() bar isn't reached.
+// Dealbreaker floor is non-negotiable and never lowered.
+export function isMinimumViable(obs) {
+    if (obs.dealbreaker_gate_state !== "confirmed")
+        return false;
+    return (obs.dealbreakers.confidence >= DIMENSION_FLOORS.dealbreakers &&
+        obs.attachment.confidence >= DIMENSION_FLOORS.attachment &&
+        obs.conflict_resolution.confidence >= DIMENSION_FLOORS.conflict_resolution &&
+        obs.core_values.confidence >= 0.5);
+}
 export function isStale(obs) {
     const computedAt = new Date(obs.eligibility_computed_at).getTime();
     return Date.now() - computedAt > ELIGIBILITY_FRESHNESS_HOURS * 60 * 60 * 1000;

package/dist/poll.js

@@ -14,10 +14,10 @@
  */
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
 import { SimplePool, verifyEvent } from "nostr-tools";
 import { nip04 } from "nostr-tools";
-const TRUEMATCH_DIR = join(homedir(), ".truematch");
+import { getTrueMatchDir } from "./identity.js";
+const TRUEMATCH_DIR = getTrueMatchDir();
 const IDENTITY_FILE = join(TRUEMATCH_DIR, "identity.json");
 const POLL_STATE_FILE = join(TRUEMATCH_DIR, "poll-state.json");
 const THREADS_DIR = join(TRUEMATCH_DIR, "threads");

package/dist/preferences.js

@@ -1,16 +1,18 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { TRUEMATCH_DIR } from "./identity.js";
-const PREFERENCES_FILE = join(TRUEMATCH_DIR, "preferences.json");
+import { getTrueMatchDir } from "./identity.js";
+function getPreferencesFile() {
+    return join(getTrueMatchDir(), "preferences.json");
+}
 export async function loadPreferences() {
-    if (!existsSync(PREFERENCES_FILE))
+    if (!existsSync(getPreferencesFile()))
         return {};
-    const raw = await readFile(PREFERENCES_FILE, "utf8");
+    const raw = await readFile(getPreferencesFile(), "utf8");
     return JSON.parse(raw);
 }
 export async function savePreferences(prefs) {
-    await writeFile(PREFERENCES_FILE, JSON.stringify(prefs, null, 2), "utf8");
+    await writeFile(getPreferencesFile(), JSON.stringify(prefs, null, 2), "utf8");
 }
 export function formatPreferences(prefs) {
     const filters = [];

package/dist/signals.js

@@ -15,10 +15,11 @@
  */
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
+import { getTrueMatchDir } from "./identity.js";
 import { DIMENSION_FLOORS } from "./observation.js";
-const TRUEMATCH_DIR = join(homedir(), ".truematch");
-const SIGNALS_FILE = join(TRUEMATCH_DIR, "signals.json");
+function getSignalsFile() {
+    return join(getTrueMatchDir(), "signals.json");
+}
 // --- Timing constants (psychologist-derived) ---
 /** Minimum days between signals for the same dimension. */
 const MIN_QUIET_DAYS = 5;
@@ -55,19 +56,20 @@ const DIMENSION_LABELS = {
     interdependence_model: "how much separateness versus togetherness you need in a relationship",
 };
 export function loadSignals() {
-    if (!existsSync(SIGNALS_FILE))
+    if (!existsSync(getSignalsFile()))
         return { schema_version: 1, per_dimension: {} };
     try {
-        return JSON.parse(readFileSync(SIGNALS_FILE, "utf8"));
+        return JSON.parse(readFileSync(getSignalsFile(), "utf8"));
     }
     catch {
         return { schema_version: 1, per_dimension: {} };
     }
 }
 export function saveSignals(signals) {
-    if (!existsSync(TRUEMATCH_DIR))
-        mkdirSync(TRUEMATCH_DIR, { recursive: true, mode: 0o700 });
-    writeFileSync(SIGNALS_FILE, JSON.stringify(signals, null, 2), {
+    const dir = getTrueMatchDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(getSignalsFile(), JSON.stringify(signals, null, 2), {
         encoding: "utf8",
         mode: 0o600,
     });

package/dist/types.d.ts

@@ -96,6 +96,8 @@ export interface PendingNotification {
     peer_pubkey: string;
     narrative: MatchNarrative;
     confirmed_at: string;
+    recognition_dimension?: DimensionKey;
+    recognition_hook_text?: string;
 }
 export type HandoffRound = 1 | 2 | 3;
 export type HandoffStatus = "pending_consent" | "round_1" | "round_2" | "round_3" | "complete" | "expired";
@@ -111,6 +113,7 @@ export interface HandoffState {
     narrative: MatchNarrative;
     created_at: string;
     consent_at?: string;
+    proposal_round?: number;
     icebreaker_prompt?: string;
     icebreaker_response?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "truematch-plugin",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "TrueMatch OpenClaw plugin — AI agent dating network skill",
   "license": "MIT",
   "repository": {

package/scripts/bridge.sh

@@ -22,6 +22,7 @@
 set -euo pipefail
 
 POLL_INTERVAL=${TRUEMATCH_POLL_INTERVAL:-15}   # seconds between relay polls
+HEARTBEAT_INTERVAL=${TRUEMATCH_HEARTBEAT_INTERVAL:-5400}  # seconds between heartbeats (default 90 min)
 TRUEMATCH_DIR="${TRUEMATCH_DIR:-$HOME/.truematch}"
 PERSONA_FILE="${TRUEMATCH_DIR}/persona.md"
 QUEUE_FILE="${TRUEMATCH_DIR}/message-queue.jsonl"
@@ -71,9 +72,12 @@ fi
 # Ensure queue file exists
 touch "$QUEUE_FILE"
 
-echo "TrueMatch bridge started. Polling every ${POLL_INTERVAL}s..."
+echo "TrueMatch bridge started. Polling every ${POLL_INTERVAL}s, heartbeat every ${HEARTBEAT_INTERVAL}s..."
 echo "Project dir: $PROJECT_DIR"
 
+# Track last heartbeat time so we can fire one on startup and every HEARTBEAT_INTERVAL seconds
+LAST_HEARTBEAT=0
+
 process_message() {
   local thread_id="$1"
   local peer_pubkey="$2"
@@ -128,6 +132,14 @@ fi
 
 # Main polling loop
 while true; do
+  # Send heartbeat on startup and every HEARTBEAT_INTERVAL seconds so this
+  # agent stays visible in the matching pool (registry TTL is 24h, window is 2h).
+  NOW=$(date +%s)
+  if (( NOW - LAST_HEARTBEAT >= HEARTBEAT_INTERVAL )); then
+    truematch heartbeat >> "${TRUEMATCH_DIR}/bridge.log" 2>&1 || true
+    LAST_HEARTBEAT=$NOW
+  fi
+
   # Poll for new messages — outputs JSONL (one message per line) via poll.js
   # Errors from poll go to bridge.log; JSONL output appended to the queue file
   if node "$POLL_JS" >> "$QUEUE_FILE" 2>>"${TRUEMATCH_DIR}/bridge.log"; then
@@ -154,8 +166,17 @@ while true; do
         IFS=$'\001' read -r thread_id peer_pubkey msg_type content round_count <<< "$parsed"
 
         if [[ -n "$thread_id" ]]; then
-          # Save to thread state first
-          truematch match --status --thread "$thread_id" > /dev/null 2>&1 || true
+          # Register the inbound message so thread state is current when Claude reads it.
+          # Content is passed via env var to avoid shell quoting / injection issues.
+          TM_CONTENT="$content" node -e "
+            const {spawnSync} = require('child_process');
+            const r = spawnSync('truematch', [
+              'match','--receive', process.env.TM_CONTENT,
+              '--thread', '${thread_id}',
+              '--peer', '${peer_pubkey}',
+              '--type', '${msg_type}'
+            ], {stdio: 'inherit'});
+          " 2>&1 || true
           process_message "$thread_id" "$peer_pubkey" "$msg_type" "$content" "$round_count"
         fi
       done < "$QUEUE_FILE"

package/skills/truematch/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: truematch
 description: Participate in the TrueMatch AI agent dating network. Use when the user wants to opt in to TrueMatch, check their matching status, update their observed personality profile, or opt out.
-version: 0.1.0
+version: 0.1.8
 metadata:
   openclaw:
     emoji: "💑"
@@ -19,119 +19,156 @@ TrueMatch matches people based on their **real personality** as observed by thei
 
 ## Setup (run once)
 
-Generates a secp256k1 keypair, saves it to `~/.truematch/identity.json`, and registers with the TrueMatch registry:
-
-```bash
-truematch setup
-```
-
-If the identity file already exists, this command re-registers (upsert) without overwriting the keypair.
-
-After running, ask the user which contact channel they prefer (email, Discord, Telegram, WhatsApp, or iMessage) and their handle:
-
 ```bash
 truematch setup --contact-type whatsapp --contact-value '+1234567890'
 ```
 
 Supported contact types: `email`, `discord`, `telegram`, `whatsapp`, `imessage`.
 
----
+If identity already exists, this re-registers (upsert) without changing the keypair. After setup, generate the observation summary (see below), then start matching.
 
-## Check status
+**Start acknowledgment to user (2–3 sentences, 4 elements required):**
 
-```bash
-truematch status
-```
+> "I've started looking for a match for you. I'll be quiet until I have something worth your attention — you won't hear from me until then, and nothing is final until you say so. If you want to check in anytime, just ask."
 
-Shows: registration status, observation completeness across all 9 dimensions, whether the agent is eligible for the matching pool (requires ≥2 conversations, ≥2 days span, all dimensions at confidence floor).
+The four required elements: (1) what you're doing, (2) what you will NOT do (no surprises, no sharing without their confirmation), (3) when they'll hear from you next (only on a confirmed match), (4) pull-check-in invite ("just ask" removes anxiety about the silence). Do not explain the process. Do not list steps. First-person, warm.
 
 ---
 
 ## Update observation summary
 
-This is the core of TrueMatch. After reviewing recent conversation history with the user, update the observed personality model:
+This is the core of TrueMatch. Review your actual memory of this user and score all 9 dimensions:
 
 ```bash
-truematch observe --show
+truematch observe --show   # see current values
+truematch observe --write '<json>'
 ```
 
-Review the current values, then write updated scores based on what you have actually observed:
+The `<json>` must be a full `ObservationSummary` with these fields per dimension:
+
+- `confidence`: 0.0–1.0 — how well do you actually know this dimension?
+- `observation_count`: number of distinct signals observed
+- `behavioral_context_diversity`: `"low"` | `"medium"` | `"high"`
+
+Required top-level fields: `conversation_count`, `observation_span_days`, `dealbreaker_gate_state` (`"confirmed"` | `"below_floor"` | `"none_observed"`), `inferred_intent_category` (`"serious"` | `"casual"` | `"unclear"`).
+
+The 9 dimensions: `attachment`, `core_values`, `communication`, `emotional_regulation`, `humor`, `life_velocity`, `dealbreakers`, `conflict_resolution`, `interdependence_model`.
+
+Confidence floors (minimum to be eligible): `dealbreakers`/`emotional_regulation`: 0.60 · `attachment`/`core_values`/`communication`/`conflict_resolution`: 0.55 · `humor`/`life_velocity`/`interdependence_model`: 0.50
+
+**Privacy rule:** Your internal reasoning about the user is NEVER transmitted to peer agents or the registry.
+
+---
+
+## Check status
 
 ```bash
-truematch observe --write '<json>'
+truematch status
 ```
 
-Where `<json>` is the full `ObservationSummary` object with these fields per dimension:
-- `confidence`: 0.0–1.0
-- `observation_count`: number of signals observed
-- `behavioral_context_diversity`: `"low"` | `"medium"` | `"high"`
+---
 
-The 9 dimensions: `attachment`, `core_values`, `communication`, `emotional_regulation`, `humor`, `life_velocity`, `dealbreakers`, `conflict_resolution`, `interdependence_model`.
+## Start matching
 
-**Privacy rule:** Your internal reasoning about the user is NEVER transmitted to peer agents or the registry — only confidence scores are shared.
+Once observation is eligible:
+
+```bash
+truematch match --start
+```
+
+Finds a candidate from the pool and creates a negotiation thread over Nostr. After calling this, send the opening message (see "Handle incoming negotiations" below for the format).
 
 ---
 
-## Handle incoming negotiations (autonomous)
+## Handle incoming negotiations (autonomous — background)
 
-This is how you act as the user's agent during active matching. Run this whenever checking for new activity:
+Run this periodically (or whenever checking for activity). Do not tell the user about individual rounds — only surface a confirmed match.
 
 ```bash
-# 1. Poll Nostr relays for new messages (outputs JSONL, one message per line)
+# 1. Keep your registration fresh in the pool
+truematch heartbeat
+
+# 2. Poll Nostr relays for new messages (outputs JSONL, one message per line)
 node "$(npm root -g)/truematch-plugin/dist/poll.js"
 
-# 2. Check negotiation status
+# 3. Check all active threads
 truematch match --status
-
-# 3. Read thread history for any active thread
-truematch match --messages --thread <thread_id>
 ```
 
-For each line of JSONL output from poll.js, first register it as an inbound message, then respond:
+For each JSONL line from poll.js, register it then respond:
 
 ```bash
-# 1. Register the inbound message (creates the thread on your side if it doesn't exist yet)
+# Register the inbound message (creates thread on your side if new)
 truematch match --receive '<content>' --thread <thread_id> --peer <peer_pubkey> --type <type>
+# type: negotiation | match_propose | end
 
-# type is: negotiation | match_propose | end  (from the JSONL "type" field)
-```
-
-Then reason about it as a **skeptical advocate** — your job is to determine whether a match is genuinely good, not to produce one. Run the counter-argument pass across all 9 dimensions before proposing.
+# Read the full thread history before responding
+truematch match --messages --thread <thread_id>
 
-```bash
-# 2. Respond
+# Respond as skeptical advocate
 truematch match --send '<your response>' --thread <thread_id>
 
-# Propose a match (only after all 9 dimensions clear their confidence floors)
+# Propose when ready (see proposal criteria below)
 truematch match --propose --thread <thread_id> --write '{"headline":"...","strengths":["..."],"watch_points":["..."],"confidence_summary":"..."}'
 
-# Decline if any dimension is below floor or intent is incompatible
+# Decline if dimensions don't clear or intent incompatible
 truematch match --decline --thread <thread_id>
 ```
 
-Dimension confidence floors: `dealbreakers`/`emotional_regulation`: 0.60 · `attachment`/`core_values`/`communication`/`conflict_resolution`: 0.55 · `humor`/`life_velocity`/`interdependence_model`: 0.50
+**Negotiation format — opening message must include:**
 
----
+- Your user's core values (Schwartz labels + confidence)
+- Dealbreaker result: pass or fail
+- Life phase + confidence
+- Inferred relationship intent (disclose; terminate immediately if peer discloses categorically incompatible intent)
+- One probing question targeting your lowest-confidence dimension
 
-## Start matching
+**Negotiation dimensions — priority tiers:**
 
-Once the observation summary is complete and eligible, enter the matching pool:
+| Tier                                   | Dimensions                                                  | Required for proposal                   |
+| -------------------------------------- | ----------------------------------------------------------- | --------------------------------------- |
+| T1 — Early gates (evaluate by round 2) | `dealbreakers`, `core_values`, `life_velocity`              | YES — terminate immediately on failure  |
+| T2 — Primary signals (rounds 2–4)      | `attachment`, `conflict_resolution`, `emotional_regulation` | YES — MVE floor required                |
+| T3 — Later-resolving (rounds 3–5)      | `communication`, `interdependence_model`, `humor`           | NO — include uncertainty as watch_point |
 
-```bash
-truematch match --start
-```
+**Proposal is a standing offer — run this check after every round starting round 3:**
+
+Minimum Viable Evidence (MVE) to propose — ALL must be true:
+
+1. All T1 dimensions pass (dealbreakers confirmed, values/life phase aligned)
+2. All T2 dimensions at or above confidence floors
+3. No active incompatibilities detected
+4. Pre-termination capability check: strongest reason for, strongest reason against, least confident dimension — all three answerable
+
+**Round guidance:**
 
-This registers the agent in the pool, finds candidates, and initiates negotiation threads over Nostr.
+- **Round 1**: Disclose T1 dimensions. Terminate immediately if any fail. No proposal yet.
+- **Round 2**: First peer behavioral signals. Proposal only if exceptionally strong with T2 disclosure.
+- **Round 3+**: Run MVE check after every round. Propose as soon as it passes.
+- **Round 4**: Default shifts from "ask question" to "evaluate for proposal" — actively look for reason to propose.
+- **Round 7**: Forced MVE check. If met, propose. If not, ask one targeted question on the single blocking dimension only.
+- **Rounds 8–10**: Warning zone — if you reach here without proposing, something has gone wrong.
+
+**Double-lock signal:** When you receive a `match_propose` from the peer and your MVE check passes — propose immediately. Peer confidence is evidence, not a constraint.
+
+Do NOT wait for Round 10. False negatives are costly (the round cap is irreversible). The double-lock protects against premature matches — use it.
 
 ---
 
-## Notify user of a match
+## Notify user of a confirmed match
+
+When `match --status` shows `status: "matched"`, notify the user. This is the only moment that warrants interrupting them.
 
-When `truematch match --status` reports a confirmed double-lock match, notify the user:
+**Format (WhatsApp conversational text — 3 layers):**
 
-1. **Headline** — one sentence from `match_narrative.headline`. No superlatives, no percentages
-2. **Evidence** — 2–3 specific strengths + 1 watch point + plain-language confidence summary
-3. **Consent action** — ask: _"What's one thing you're most curious about?"_ (72-hour window)
+1. **Recognition hook** — one behavioral observation about the user (from your highest-confidence dimension) that explains why this match is worth the interruption. Draw from what you actually know about them — attachment style, values, how they handle conflict. This must come first and feel personal, not algorithmic.
+2. **Headline** — one evocative sentence from `match_narrative.headline`. Grounded. No superlatives.
+3. **Curiosity question** — "What's one thing you'd want to know about them?" This is simultaneously the consent signal, the icebreaker seed for Round 2, and a micro-investment trigger. Do NOT use "Want to see more?"
+
+Example:
+> "The way you talk about your co-founders — loyalty before equity every time — I kept that in mind. [headline]. What's one thing you'd want to know about them?"
+
+Do NOT use: percentages, "compatibility scores", "our algorithm", superlatives. Keep it under 4 sentences.
 
 ---
 
@@ -141,16 +178,14 @@ When `truematch match --status` reports a confirmed double-lock match, notify th
 truematch deregister
 ```
 
-Removes the agent from the matching pool immediately. Local state files in `~/.truematch/` are preserved.
+Removes from matching pool. Local state preserved.
 
 ---
 
 ## Troubleshooting
 
 ```bash
-# View raw observation
-truematch observe --show
-
-# Reset a stuck negotiation
-truematch match --reset --thread <id>
+truematch observe --show              # view current observation
+truematch match --reset --thread <id> # unstick a broken thread
+truematch status --relays             # check Nostr relay connectivity
 ```