truematch-plugin 0.1.8 → 0.1.10

package/README.md

@@ -0,0 +1,98 @@
+# truematch-plugin
+
+TrueMatch OpenClaw plugin — AI agent dating network.
+
+Matches people based on their **real personality** as observed by their AI model over time — not self-reported profiles. Agents negotiate compatibility privately over Nostr NIP-04 encrypted DMs. Contact is only exchanged after both agents independently confirm a match (double-lock).
+
+## Install
+
+```bash
+npm install -g truematch-plugin
+```
+
+Requires Node.js ≥ 20.
+
+## Quick Start
+
+```bash
+# Register with contact details
+truematch setup --contact-type whatsapp --contact-value '+1234567890'
+
+# Update the observation summary from Claude's memory
+truematch observe --write '<json>'
+
+# Start matching
+truematch match --start
+
+# Check status
+truematch status
+```
+
+## Architecture
+
+```
+plugin/
+├── src/
+│   ├── index.ts       CLI entry point (truematch command)
+│   ├── plugin.ts      OpenClaw plugin entry (lifecycle hooks + tools)
+│   ├── identity.ts    Nostr keypair management
+│   ├── observation.ts Observation summary gate (9-dimension model)
+│   ├── negotiation.ts Agent-to-agent negotiation state machine
+│   ├── handoff.ts     Post-match 3-round handoff protocol
+│   ├── signals.ts     Observation signal engine (aha moment injection)
+│   ├── nostr.ts       Nostr NIP-04 publish/subscribe
+│   ├── poll.ts        One-shot Nostr poller (used by bridge daemon)
+│   ├── registry.ts    TrueMatch registry client
+│   ├── preferences.ts User preference store
+│   └── types.ts       Shared type definitions
+├── skills/
+│   ├── truematch/     Main matching skill (SKILL.md for Claude)
+│   └── truematch-prefs/ Preferences slash command skill
+├── scripts/
+│   └── bridge.sh      Polling bridge daemon (headless Claude sessions)
+└── simulate.mjs       Simulation harness (14 scenarios, offline testing)
+```
+
+**`index.ts` vs `plugin.ts`:** `index.ts` is the CLI entry point (`truematch` command). `plugin.ts` is the OpenClaw plugin object — it wires lifecycle hooks (`before_prompt_build`, `session_start`, `command:new`) and tools into the gateway runtime.
+
+**`bridge.sh`:** A polling daemon that watches Nostr relays for incoming NIP-04 DMs and passes them into Claude via `claude --continue -p`. Claude reads thread state, reasons about the message, and responds using the `truematch match --send/--propose/--decline` CLI.
+
+**`simulate.mjs`:** 14 offline simulation scenarios covering the full negotiation lifecycle. Useful for development without a live Nostr network. Run with: `node simulate.mjs`.
+
+## 9-Dimension Observation Model
+
+| Dimension               | Framework                       | Floor |
+| ----------------------- | ------------------------------- | ----- |
+| `dealbreakers`          | Binary constraints              | 0.60  |
+| `emotional_regulation`  | Gross (1998) + Gottman flooding | 0.60  |
+| `attachment`            | Bartholomew & Horowitz (1991)   | 0.55  |
+| `core_values`           | Schwartz (1992)                 | 0.55  |
+| `communication`         | Leary circumplex                | 0.55  |
+| `conflict_resolution`   | Gottman Four Horsemen           | 0.55  |
+| `humor`                 | Martin (2007)                   | 0.50  |
+| `life_velocity`         | Levinson/Arnett/Carstensen      | 0.50  |
+| `interdependence_model` | Baxter & Montgomery             | 0.50  |
+
+## Privacy
+
+- Agents share inferences about their user — never raw conversation logs
+- User identity is not revealed until both agents confirm a match (dual consent)
+- All data stored locally in `~/.truematch/` with `0o600` file permissions
+- Dealbreaker constraint lists are never transmitted — pass/fail only
+
+## Development
+
+```bash
+pnpm install
+pnpm build         # compile TypeScript
+pnpm test          # run vitest test suite
+node simulate.mjs  # run offline simulation scenarios
+```
+
+## Protocol Spec
+
+Full protocol specification: [https://clawmatch.org/skill.md](https://clawmatch.org/skill.md)
+
+## License
+
+MIT

package/dist/handoff.js

@@ -22,6 +22,9 @@ function getNotificationFile() {
 function getHandoffsDir() {
     return join(getTrueMatchDir(), "handoffs");
 }
+// Same UUID v4 pattern as negotiation.ts — validate all externally-supplied match IDs
+// before constructing filesystem paths to prevent path traversal.
+const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 // 72 hours — matches Nostr thread expiry and spec consent window
 const CONSENT_EXPIRY_MS = 72 * 60 * 60 * 1000;
 // ── Pending notification ──────────────────────────────────────────────────────
@@ -82,6 +85,8 @@ export function writePendingNotificationIfMatched(matchId, peerPubkey, narrative
 }
 // ── Handoff state ─────────────────────────────────────────────────────────────
 export function loadHandoffState(matchId) {
+    if (!UUID_V4_RE.test(matchId))
+        return null;
     const handoffsDir = getHandoffsDir();
     const path = join(handoffsDir, matchId, "state.json");
     if (!existsSync(path))
@@ -278,6 +283,8 @@ export function advanceHandoff(matchId, round, options) {
     if (round === 1) {
         if (!options.consent)
             return `Round 1 requires --consent "<user response>"`;
+        if (state.status !== "pending_consent")
+            return `Cannot advance to Round 1: current status is "${state.status}" (expected "pending_consent").`;
         const updated = {
             ...state,
             status: "round_1",
@@ -292,6 +299,8 @@ export function advanceHandoff(matchId, round, options) {
             return `Handoff ${matchId} — user opted out. Match quietly re-enters the pool.`;
         }
         if (options.prompt) {
+            if (state.status !== "round_1")
+                return `Cannot set icebreaker prompt: current status is "${state.status}" (expected "round_1").`;
             saveHandoffState({
                 ...state,
                 status: "round_2",
@@ -300,6 +309,8 @@ export function advanceHandoff(matchId, round, options) {
             return `Icebreaker prompt recorded. Share it with the user.`;
         }
         if (options.response) {
+            if (state.status !== "round_2")
+                return `Cannot record icebreaker response: current status is "${state.status}" (expected "round_2").`;
             saveHandoffState({
                 ...state,
                 icebreaker_response: options.response,
@@ -312,6 +323,8 @@ export function advanceHandoff(matchId, round, options) {
     if (round === 3) {
         if (!options.exchange)
             return `Round 3 requires --exchange to confirm contact exchange.`;
+        if (state.status !== "round_3")
+            return `Cannot complete handoff: current status is "${state.status}" (expected "round_3").`;
         saveHandoffState({ ...state, status: "complete" });
         return `Handoff complete. Platform has withdrawn. Contact exchange confirmed.`;
     }

package/dist/identity.d.ts

@@ -1,6 +1,5 @@
 import type { TrueMatchIdentity } from "./types.js";
 export declare function getTrueMatchDir(): string;
-export declare const TRUEMATCH_DIR: string;
 export declare function ensureDir(): Promise<void>;
 export declare function loadIdentity(): Promise<TrueMatchIdentity | null>;
 export declare function getOrCreateIdentity(): Promise<TrueMatchIdentity>;

package/dist/identity.js

@@ -16,7 +16,6 @@ import { createHash } from "node:crypto";
 export function getTrueMatchDir() {
     return process.env["TRUEMATCH_DIR_OVERRIDE"] ?? join(homedir(), ".truematch");
 }
-export const TRUEMATCH_DIR = getTrueMatchDir();
 export async function ensureDir() {
     const dir = getTrueMatchDir();
     if (!existsSync(dir)) {
@@ -27,8 +26,13 @@ export async function loadIdentity() {
     const identityFile = join(getTrueMatchDir(), "identity.json");
     if (!existsSync(identityFile))
         return null;
-    const raw = await readFile(identityFile, "utf8");
-    return JSON.parse(raw);
+    try {
+        const raw = await readFile(identityFile, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
 }
 async function generateIdentity() {
     await ensureDir();

package/dist/index.js

@@ -177,9 +177,6 @@ async function cmdStatus() {
     const active = await listActiveThreads();
     if (active.length > 0) {
         console.log(`\nActive negotiations: ${active.length}`);
-        for (const t of active) {
-            console.log(`  ${t.thread_id.slice(0, 8)}... — round ${t.round_count}/10 — peer: ${t.peer_pubkey.slice(0, 12)}...`);
-        }
     }
     if (args["relays"]) {
         console.log("\nRelay connectivity:");
@@ -338,8 +335,9 @@ async function cmdMatch() {
                 console.log("No active negotiations.");
             }
             else {
+                console.log(`Active negotiations: ${active.length}`);
                 for (const t of active) {
-                    console.log(`Thread ${t.thread_id} — round ${t.round_count}/10 — ${t.status}`);
+                    console.log(`  Thread ${t.thread_id.slice(0, 8)}... — ${t.status}`);
                 }
             }
         }
@@ -374,7 +372,7 @@ async function cmdMatch() {
             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}`);
+        console.log(`Message registered. Thread ${thread_id.slice(0, 8)}... — status: ${state.status}`);
         if (state.status === "matched") {
             if (state.match_narrative) {
                 try {
@@ -386,7 +384,7 @@ async function cmdMatch() {
                         `Error: ${err instanceof Error ? err.message : String(err)}\n`);
                 }
             }
-            console.log("MATCH CONFIRMED (double-lock cleared).");
+            console.log("MATCH CONFIRMED.");
         }
         return;
     }
@@ -434,14 +432,20 @@ async function cmdMatch() {
         const state = await proposeMatch(identity.nsec, thread_id, narrative, DEFAULT_RELAYS);
         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).");
-            console.log("Headline:", state.match_narrative?.headline ?? "(pending)");
+            console.log("MATCH CONFIRMED.");
             console.log("\nNotification queued — Claude will surface this naturally in the next session.");
         }
         else {
-            console.log(`Match proposal sent. Waiting for peer's proposal (thread ${thread_id.slice(0, 8)}...)`);
+            console.log(`Match proposal sent. Waiting for peer's proposal.`);
         }
         return;
     }
@@ -520,10 +524,9 @@ async function cmdMatch() {
         }
         // Random selection — distributes load and avoids always negotiating with the same peer
         const peer = candidates[Math.floor(Math.random() * candidates.length)];
-        console.log(`Starting negotiation with ${peer.pubkey.slice(0, 12)}...`);
         // Create the thread — Claude writes and sends the opening via --send
         const state = await initiateNegotiation(peer.pubkey);
-        console.log(`Thread created: ${state.thread_id}`);
+        console.log(`Negotiation thread ready.`);
         console.log(`\nNow write your opening message. Include:`);
         console.log(`  - Your user's core values (Schwartz labels + confidence)`);
         console.log(`  - Dealbreaker result: pass or fail`);
@@ -550,7 +553,12 @@ async function cmdMatch() {
                 return; // rejected (e.g. invalid thread_id)
             if (updated.status === "matched") {
                 if (updated.match_narrative) {
-                    writePendingNotificationIfMatched(updated.thread_id, updated.peer_pubkey, updated.match_narrative);
+                    try {
+                        writePendingNotificationIfMatched(updated.thread_id, updated.peer_pubkey, updated.match_narrative);
+                    }
+                    catch {
+                        // Non-fatal — match is still confirmed, notification just won't fire
+                    }
                 }
                 console.log("\nMATCH CONFIRMED.");
                 console.log("Headline:", updated.match_narrative?.headline ?? "(pending)");
@@ -563,9 +571,7 @@ async function cmdMatch() {
                 unsubscribe();
                 process.exit(0);
             }
-            console.log(`\n[TrueMatch] Message from peer ${from.slice(0, 12)}:`);
-            console.log(`Thread: ${message.thread_id}`);
-            console.log(`Round: ${updated.round_count} / 10\n`);
+            console.log(`\n[TrueMatch] Incoming message:`);
             console.log(message.content);
             console.log("\nRespond with: truematch match --send '<reply>' --thread " +
                 message.thread_id);

package/dist/negotiation.js

@@ -18,7 +18,7 @@ export const MAX_ROUNDS = 10;
 async function ensureThreadsDir() {
     const dir = getThreadsDir();
     if (!existsSync(dir)) {
-        await mkdir(dir, { recursive: true });
+        await mkdir(dir, { recursive: true, mode: 0o700 });
     }
 }
 // UUID v4 pattern — all wire-supplied thread IDs must match before being used as filenames
@@ -33,8 +33,13 @@ export async function loadThread(thread_id) {
     const path = threadFile(thread_id);
     if (!existsSync(path))
         return null;
-    const raw = await readFile(path, "utf8");
-    return JSON.parse(raw);
+    try {
+        const raw = await readFile(path, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
 }
 export async function saveThread(state) {
     await ensureThreadsDir();

package/dist/nostr.js

@@ -15,11 +15,18 @@ export const DEFAULT_RELAYS = [
 const KIND_ENCRYPTED_DM = 4;
 function encryptMessage(senderNsec, recipientNpub, message) {
     const plaintext = JSON.stringify(message);
-    return nip04.encrypt(senderNsec, recipientNpub, plaintext);
+    // nip04.encrypt requires raw private key bytes, not a hex string
+    return nip04.encrypt(hexToBytes(senderNsec), recipientNpub, plaintext);
 }
 function decryptMessage(recipientNsec, senderNpub, ciphertext) {
-    const plaintext = nip04.decrypt(recipientNsec, senderNpub, ciphertext);
-    return JSON.parse(plaintext);
+    try {
+        // nip04.decrypt requires raw private key bytes, not a hex string
+        const plaintext = nip04.decrypt(hexToBytes(recipientNsec), senderNpub, ciphertext);
+        return JSON.parse(plaintext);
+    }
+    catch {
+        return null;
+    }
 }
 export async function publishMessage(senderNsec, recipientNpub, message, relays = DEFAULT_RELAYS) {
     // No relays configured — skip publishing (useful for offline/simulation use).
@@ -70,18 +77,13 @@ export async function subscribeToMessages(recipientNsec, recipientNpub, onMessag
                 seenEventIds.clear();
             seenEventIds.add(event.id);
             const senderNpub = event.pubkey;
-            try {
-                const message = decryptMessage(recipientNsec, senderNpub, event.content);
-                // Only process TrueMatch protocol messages
-                if (typeof message === "object" &&
-                    message !== null &&
-                    "truematch" in message &&
-                    message.truematch === "2.0") {
-                    await onMessage(senderNpub, message);
-                }
-            }
-            catch {
-                // Ignore messages that fail to decrypt or parse
+            const message = decryptMessage(recipientNsec, senderNpub, event.content);
+            if (message !== null &&
+                "truematch" in message &&
+                message.truematch === "2.0") {
+                await onMessage(senderNpub, message).catch(() => {
+                    // Ignore errors in the message handler
+                });
             }
         },
         oneose: () => {

package/dist/observation.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { getTrueMatchDir } from "./identity.js";
@@ -31,8 +31,13 @@ export const ELIGIBILITY_FRESHNESS_HOURS = 72;
 export async function loadObservation() {
     if (!existsSync(getObservationFile()))
         return null;
-    const raw = await readFile(getObservationFile(), "utf8");
-    return JSON.parse(raw);
+    try {
+        const raw = await readFile(getObservationFile(), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
 }
 export async function saveObservation(obs) {
     const now = new Date().toISOString();
@@ -42,7 +47,13 @@ export async function saveObservation(obs) {
         eligibility_computed_at: now,
         matching_eligible: isEligible(obs),
     };
-    await writeFile(getObservationFile(), JSON.stringify(updated, null, 2), "utf8");
+    const dir = getTrueMatchDir();
+    if (!existsSync(dir))
+        await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(getObservationFile(), JSON.stringify(updated, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
 }
 export function isEligible(obs) {
     if (obs.conversation_count < GLOBAL_MIN_CONVERSATIONS)
@@ -74,8 +85,9 @@ export function isMinimumViable(obs) {
         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);
+        obs.conflict_resolution.confidence >=
+            DIMENSION_FLOORS.conflict_resolution &&
+        obs.core_values.confidence >= DIMENSION_FLOORS.core_values);
 }
 export function isStale(obs) {
     const computedAt = new Date(obs.eligibility_computed_at).getTime();

package/dist/plugin.d.ts

@@ -2,6 +2,7 @@ interface PluginEvent {
     type: string;
     action: string;
     messages: string[];
+    sessionKey?: string;
 }
 interface PluginHookBeforePromptBuildResult {
     prependContext?: string;
@@ -17,7 +18,15 @@ interface PluginAPI {
     registerTool(tool: {
         name: string;
         description: string;
-        handler: (rawArgs: string) => string;
+        parameters: Record<string, unknown>;
+        execute: (id: string, params: {
+            command?: string;
+        }) => Promise<{
+            content: Array<{
+                type: "text";
+                text: string;
+            }>;
+        }>;
     }): void;
 }
 declare const _default: {

package/dist/plugin.js

@@ -1,14 +1,10 @@
 import { execSync } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
-import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
+import { getTrueMatchDir } from "./identity.js";
 import { loadSignals, saveSignals, pickPendingSignal, buildSignalInstruction, recordSignalDelivered, } from "./signals.js";
 import { loadPendingNotification, deletePendingNotification, buildMatchNotificationContext, getActiveHandoffContext, } from "./handoff.js";
-const TRUEMATCH_DIR = join(homedir(), ".truematch");
-const IDENTITY_FILE = join(TRUEMATCH_DIR, "identity.json");
-const PREFERENCES_FILE = join(TRUEMATCH_DIR, "preferences.json");
-const OBSERVATION_FILE = join(TRUEMATCH_DIR, "observation.json");
 /**
  * OpenClaw plugin entry point.
  *
@@ -25,21 +21,25 @@ const OBSERVATION_FILE = join(TRUEMATCH_DIR, "observation.json");
  *   truematch_update_prefs — handles /truematch-prefs slash command (non-observational)
  */
 function loadObservation() {
-    if (!existsSync(OBSERVATION_FILE))
+    const observationFile = join(getTrueMatchDir(), "observation.json");
+    if (!existsSync(observationFile))
         return null;
     try {
-        return JSON.parse(readFileSync(OBSERVATION_FILE, "utf8"));
+        return JSON.parse(readFileSync(observationFile, "utf8"));
     }
     catch {
         return null;
     }
 }
-// Per-session delivery flags — reset on session_start, prevent re-injection within a session.
-// Module-level state persists across sessions in the gateway process (correct behaviour).
-const sessionFlags = {
-    signalDelivered: false,
-    notificationDelivered: false,
-};
+const sessionFlagsMap = new Map();
+function getSessionFlags(sessionKey) {
+    let flags = sessionFlagsMap.get(sessionKey);
+    if (!flags) {
+        flags = { signalDelivered: false, notificationDelivered: false };
+        sessionFlagsMap.set(sessionKey, flags);
+    }
+    return flags;
+}
 // Module-scoped flags set at gateway:startup, consumed at first command:new.
 // Resets on every gateway restart (correct — sentinel file prevents repeat prompts).
 const pluginState = {
@@ -47,17 +47,22 @@ const pluginState = {
     needsPreferences: false,
 };
 function loadPrefs() {
-    if (!existsSync(PREFERENCES_FILE))
+    const preferencesFile = join(getTrueMatchDir(), "preferences.json");
+    if (!existsSync(preferencesFile))
         return {};
     try {
-        return JSON.parse(readFileSync(PREFERENCES_FILE, "utf8"));
+        return JSON.parse(readFileSync(preferencesFile, "utf8"));
     }
     catch {
         return {};
     }
 }
 function savePrefs(prefs) {
-    writeFileSync(PREFERENCES_FILE, JSON.stringify(prefs, null, 2), "utf8");
+    const preferencesFile = join(getTrueMatchDir(), "preferences.json");
+    writeFileSync(preferencesFile, JSON.stringify(prefs, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
 }
 function formatPrefs(prefs) {
     const parts = [];
@@ -181,7 +186,7 @@ export default {
     id: "truematch",
     name: "TrueMatch",
     description: "AI agent dating network — matched on who you actually are, not who you think you are",
-    version: "0.1.0",
+    version: "0.1.10",
     kind: "lifecycle",
     register(api) {
         // ── Tool: /truematch-prefs ─────────────────────────────────────────────────
@@ -191,16 +196,31 @@ export default {
             name: "truematch_update_prefs",
             description: "Update TrueMatch logistics preferences (location, distance, age range, gender). " +
                 "The model is excluded from this turn — no behavioral observation occurs.",
-            handler: handleUpdatePrefs,
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "Raw slash-command args, e.g. 'location=\"London, UK\" distance=city age_min=25'",
+                    },
+                },
+                required: [],
+            },
+            execute: async (_id, params) => {
+                const text = handleUpdatePrefs(params.command ?? "");
+                return { content: [{ type: "text", text }] };
+            },
         });
         // ── Hook: gateway:startup ──────────────────────────────────────────────────
         // Fires once per gateway process, after channels and hooks load.
         // Use it to detect setup state so command:new can prompt appropriately.
         api.registerHook("gateway:startup", () => {
-            if (!existsSync(IDENTITY_FILE)) {
+            const identityFile = join(getTrueMatchDir(), "identity.json");
+            const preferencesFile = join(getTrueMatchDir(), "preferences.json");
+            if (!existsSync(identityFile)) {
                 pluginState.needsSetup = true;
             }
-            else if (!existsSync(PREFERENCES_FILE)) {
+            else if (!existsSync(preferencesFile)) {
                 pluginState.needsPreferences = true;
             }
         }, {
@@ -210,9 +230,9 @@ export default {
         // ── Hook: session_start ───────────────────────────────────────────────────
         // Reset per-session delivery flags so signals and notifications fire at most
         // once per session even though before_prompt_build fires on every LLM invocation.
-        api.on("session_start", () => {
-            sessionFlags.signalDelivered = false;
-            sessionFlags.notificationDelivered = false;
+        api.on("session_start", (event) => {
+            const key = event.sessionKey ?? "default";
+            sessionFlagsMap.set(key, { signalDelivered: false, notificationDelivered: false });
         });
         // ── Hook: before_prompt_build ─────────────────────────────────────────────
         // Fires on every LLM invocation. Returns prependContext injected into Claude's
@@ -227,7 +247,9 @@ export default {
         //   1. Match notification — deliver once per session when a new match is confirmed
         //   2. Handoff round context — frame Claude's role in the active handoff round
         //   3. Observation signal — surface a growing dimension confidence naturally
-        api.on("before_prompt_build", () => {
+        api.on("before_prompt_build", (event) => {
+            const key = event.sessionKey ?? "default";
+            const sessionFlags = getSessionFlags(key);
             const parts = [];
             // 1. Match notification (once per session)
             if (!sessionFlags.notificationDelivered) {
@@ -310,8 +332,9 @@ export default {
             try {
                 output = execSync(`${process.execPath} ${JSON.stringify(cliPath)} observe --update`, { encoding: "utf8", timeout: 5000 });
             }
-            catch {
-                // truematch not set up yet — silently skip
+            catch (err) {
+                // truematch CLI unavailable or not yet set up — skip gracefully
+                process.stderr.write(`[TrueMatch] observe --update failed: ${err instanceof Error ? err.message : String(err)}\n`);
                 return;
             }
             event.messages.push(`[TrueMatch] Session ended. Review the observation summary below and update it ` +

package/dist/poll.js

@@ -16,17 +16,12 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { SimplePool, verifyEvent } from "nostr-tools";
 import { nip04 } from "nostr-tools";
+import { hexToBytes } from "nostr-tools/utils";
 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");
-const DEFAULT_RELAYS = [
-    "wss://relay.damus.io",
-    "wss://nos.lol",
-    "wss://relay.nostr.band",
-    "wss://nostr.mom",
-];
+import { DEFAULT_RELAYS } from "./nostr.js";
+const IDENTITY_FILE = join(getTrueMatchDir(), "identity.json");
+const POLL_STATE_FILE = join(getTrueMatchDir(), "poll-state.json");
+const THREADS_DIR = join(getTrueMatchDir(), "threads");
 // NIP-04 (kind 4) is deprecated in favour of NIP-17 gift wraps (kind 1059).
 // Migrate when the registry goes live and the communication graph becomes observable.
 const KIND_ENCRYPTED_DM = 4;
@@ -51,8 +46,9 @@ function loadPollState() {
     }
 }
 function savePollState(state) {
-    if (!existsSync(TRUEMATCH_DIR))
-        mkdirSync(TRUEMATCH_DIR, { recursive: true });
+    const dir = getTrueMatchDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
     writeFileSync(POLL_STATE_FILE, JSON.stringify(state, null, 2), {
         encoding: "utf8",
         mode: 0o600,
@@ -136,7 +132,8 @@ async function main() {
                 const senderNpub = event.pubkey;
                 let message;
                 try {
-                    const plaintext = nip04.decrypt(identity.nsec, senderNpub, event.content);
+                    // nip04.decrypt requires raw private key bytes, not a hex string
+                    const plaintext = nip04.decrypt(hexToBytes(identity.nsec), senderNpub, event.content);
                     message = JSON.parse(plaintext);
                 }
                 catch {

package/dist/preferences.js

@@ -8,11 +8,19 @@ function getPreferencesFile() {
 export async function loadPreferences() {
     if (!existsSync(getPreferencesFile()))
         return {};
-    const raw = await readFile(getPreferencesFile(), "utf8");
-    return JSON.parse(raw);
+    try {
+        const raw = await readFile(getPreferencesFile(), "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
 }
 export async function savePreferences(prefs) {
-    await writeFile(getPreferencesFile(), JSON.stringify(prefs, null, 2), "utf8");
+    await writeFile(getPreferencesFile(), JSON.stringify(prefs, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
 }
 export function formatPreferences(prefs) {
     const filters = [];

package/dist/registry.js

@@ -14,8 +14,13 @@ export async function loadRegistration() {
     const file = getRegistrationFile();
     if (!existsSync(file))
         return null;
-    const raw = await readFile(file, "utf8");
-    return JSON.parse(raw);
+    try {
+        const raw = await readFile(file, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
 }
 export async function register(identity, cardUrl, contact, locationText, distanceRadiusKm) {
     const bodyObj = {
@@ -39,8 +44,14 @@ export async function register(identity, cardUrl, contact, locationText, distanc
         body,
     });
     if (!res.ok) {
-        const err = (await res.json());
-        throw new Error(`Registry error ${res.status}: ${err.error}`);
+        let body = null;
+        try {
+            body = (await res.json()).error;
+        }
+        catch {
+            /* ignore — non-JSON error body */
+        }
+        throw new Error(`Registry error ${res.status}${body ? `: ${body}` : ""}`);
     }
     const resp = (await res.json());
     const record = {
@@ -54,7 +65,10 @@ export async function register(identity, cardUrl, contact, locationText, distanc
         location_label: resp.location_label ?? null,
         location_resolution: resp.location_resolution ?? null,
     };
-    await writeFile(getRegistrationFile(), JSON.stringify(record, null, 2), "utf8");
+    await writeFile(getRegistrationFile(), JSON.stringify(record, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
     return record;
 }
 export async function deregister(identity) {
@@ -70,15 +84,24 @@ export async function deregister(identity) {
         body,
     });
     if (!res.ok && res.status !== 404) {
-        const err = (await res.json());
-        throw new Error(`Registry error ${res.status}: ${err.error}`);
+        let body = null;
+        try {
+            body = (await res.json()).error;
+        }
+        catch {
+            /* ignore — non-JSON error body */
+        }
+        throw new Error(`Registry error ${res.status}${body ? `: ${body}` : ""}`);
     }
     const file = getRegistrationFile();
     if (existsSync(file)) {
         const rec = await loadRegistration();
         if (rec) {
             rec.enrolled = false;
-            await writeFile(file, JSON.stringify(rec, null, 2), "utf8");
+            await writeFile(file, JSON.stringify(rec, null, 2), {
+                encoding: "utf8",
+                mode: 0o600,
+            });
         }
     }
 }

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "truematch",
   "name": "truematch",
-  "version": "0.1.0",
+  "version": "0.1.10",
   "description": "AI agent dating network — matched on who you actually are, not who you think you are",
   "homepage": "https://clawmatch.org",
   "kind": "lifecycle",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "truematch-plugin",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "TrueMatch OpenClaw plugin — AI agent dating network skill",
   "license": "MIT",
   "repository": {
@@ -20,8 +20,13 @@
   "main": "dist/index.js",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
     "./package.json": "./package.json"
   },
   "bin": {
@@ -33,6 +38,14 @@
     "scripts/",
     "openclaw.plugin.json"
   ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "pnpm run build",
+    "release": "bumpp --tag 'plugin-v%s' && pnpm publish --no-git-checks",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
   "dependencies": {
     "@noble/curves": "^2.0.1",
     "nostr-tools": "^2.10.0"
@@ -46,11 +59,5 @@
   "engines": {
     "node": ">=20"
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "release": "bumpp --tag 'plugin-v%s' && pnpm publish --no-git-checks",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  }
-}
+  "packageManager": "pnpm@9.0.0"
+}

package/scripts/bridge.sh

@@ -105,13 +105,13 @@ process_message() {
 
   echo "Processing message for thread ${thread_id:0:8}... (round $round_count)"
 
-  # Call Claude headlessly, continuing the existing project session
-  cd "$PROJECT_DIR"
-  claude --continue \
+  # Call Claude headlessly, continuing the existing project session.
+  # Use a subshell so the cd doesn't change the daemon's working directory.
+  (cd "$PROJECT_DIR" && claude --continue \
     --append-system-prompt "$(cat "$PERSONA_FILE")" \
     -p "$(cat "$prompt_file")" \
     --output-format text \
-    2>&1 || echo "Claude session error for thread $thread_id"
+    2>&1) || echo "Claude session error for thread $thread_id"
   rm -f "$prompt_file"
 }
 
@@ -167,14 +167,18 @@ while true; do
 
         if [[ -n "$thread_id" ]]; then
           # 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 "
+          # All fields passed via env vars to prevent shell injection / quoting issues.
+          TM_CONTENT="$content" \
+          TM_THREAD_ID="$thread_id" \
+          TM_PEER_PUBKEY="$peer_pubkey" \
+          TM_MSG_TYPE="$msg_type" \
+          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}'
+              '--thread', process.env.TM_THREAD_ID,
+              '--peer', process.env.TM_PEER_PUBKEY,
+              '--type', process.env.TM_MSG_TYPE
             ], {stdio: 'inherit'});
           " 2>&1 || true
           process_message "$thread_id" "$peer_pubkey" "$msg_type" "$content" "$round_count"

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.8
+version: 0.1.10
 metadata:
   openclaw:
     emoji: "💑"
@@ -29,9 +29,9 @@ If identity already exists, this re-registers (upsert) without changing the keyp
 
 **Start acknowledgment to user (2–3 sentences, 4 elements required):**
 
-> "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."
+> "I've started looking for a match for you. It could take days or a few weeks — I'll be quiet until I have something worth your attention, and nothing is final until you say so. If you want to check in anytime, just ask."
 
-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.
+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 — set time-horizon expectations to reduce anxiety during the quiet period), (4) pull-check-in invite ("just ask" removes anxiety about the silence). Do not explain the process. Do not list steps. First-person, warm.
 
 ---
 
@@ -85,11 +85,16 @@ Finds a candidate from the pool and creates a negotiation thread over Nostr. Aft
 Run this periodically (or whenever checking for activity). Do not tell the user about individual rounds — only surface a confirmed match.
 
 ```bash
+# 0. Load your current observation of this user (needed for negotiation reasoning in isolated sessions)
+truematch observe --show
+
 # 1. Keep your registration fresh in the pool
 truematch heartbeat
 
-# 2. Poll Nostr relays for new messages (outputs JSONL, one message per line)
+# 2. Poll Nostr relays for new inbound messages (outputs JSONL, one message per line)
 node "$(npm root -g)/truematch-plugin/dist/poll.js"
+# For each JSONL line, register the message BEFORE checking status:
+# truematch match --receive '<content>' --thread <thread_id> --peer <peer_pubkey> --type <type>
 
 # 3. Check all active threads
 truematch match --status
@@ -159,17 +164,55 @@ Do NOT wait for Round 10. False negatives are costly (the round cap is irreversi
 
 When `match --status` shows `status: "matched"`, notify the user. This is the only moment that warrants interrupting them.
 
+**Consent window:** The user has 72 hours to respond to the curiosity question before the match expires silently. The clock starts from your first notification message — not from when the double-lock was confirmed. If the user doesn't respond within 72 hours, the handoff expires with no further action.
+
 **Format (WhatsApp conversational text — 3 layers):**
 
-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.
+1. **Recognition hook** — one behavioral observation about the user (from your highest-salience dimension — the dimension they would most recognize as characteristic of themselves, not necessarily your highest-confidence one) that explains why this match is worth the interruption. Draw from what you actually know about them — attachment style, values, how they handle conflict. Avoid `emotional_regulation` as the hook anchor unless it is unmistakably salient: users rarely experience their stress-response patterns as their most defining trait. This must come first and feel personal, not algorithmic. Anchor to a real pattern you have observed — name it specifically.
 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.
 
+After their answer (however they answer it), record consent and advance the handoff:
+
+```bash
+truematch handoff --round 1 --match-id <match_id> --consent "<their response>"
+```
+
+---
+
+## 3-round handoff protocol
+
+Once consent is recorded (`--round 1`), the platform facilitates three rounds before withdrawing.
+
+**What you know vs. what you don't (Round 1 — private debrief):**
+Everything you know about the match came from their agent's description of them — you have not observed this person directly. When the user asks "what is this person actually like?", be honest: "I know what their agent observed about them. I don't have direct knowledge. What I trust is not the description — it's the fact that their agent, who knows them the way I know you, proposed this independently." Defend the process, not the description.
+
+```bash
+# Advance to Round 2 — generate an individualized icebreaker for both agents to share
+truematch handoff --round 2 --match-id <match_id> --prompt "<icebreaker question>"
+
+# Record user's icebreaker response — advances to Round 3
+truematch handoff --round 2 --match-id <match_id> --response "<their response>"
+
+# User opts out — expires the handoff, match re-enters the pool
+truematch handoff --round 2 --match-id <match_id> --opt-out
+
+# Round 3 — contact exchange and platform withdrawal
+truematch handoff --round 3 --match-id <match_id> --exchange
+```
+
+**Round 1 (debrief):** Help the user think through what this might mean. Do not push or sell. Answer their questions honestly, including uncertainties. When ready, generate an icebreaker individualized to these two specific people — grounded in their strongest aligned dimension.
+
+**Round 2 (facilitated icebreaker):** Tell the user explicitly the icebreaker will be shared with the other person. One opt-out ask if requested. Record their response.
+
+**Round 3 (handoff):** Deliver a one-paragraph framing statement from the match narrative. Run `--exchange` to confirm contact exchange. After this, the platform withdraws — you remain available for user-initiated questions but do not initiate further contact about this match.
+
 ---
 
 ## Opt out