truematch-plugin 0.1.0

package/dist/signals.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Observation signal engine.
+ *
+ * Decides when Claude should naturally surface a growing observation to the user.
+ * Signals are injected into Claude's context via the agent:bootstrap hook — addressed
+ * to Claude as an internal note, not displayed directly to the user.
+ *
+ * Design principles (from psychologist + teen researcher findings):
+ *   - Language: inference-based, ambiguous-to-curious valence ("something about how
+ *     you talk about X keeps staying with me")
+ *   - Timing: first signal only after session ≥2, then 5+ day quiet periods
+ *   - One signal per session maximum — pick the dimension with the largest growth delta
+ *   - Never mention matching, compatibility, or the algorithm
+ *   - Do not force it — Claude decides the conversational moment, plugin decides the condition
+ */
+import type { ObservationSummary, DimensionKey, SignalsFile } from "./types.js";
+export declare function loadSignals(): SignalsFile;
+export declare function saveSignals(signals: SignalsFile): void;
+/**
+ * Pick the single best dimension to signal this session.
+ * Returns null if nothing qualifies (too early, quiet period, or no meaningful growth).
+ */
+export declare function pickPendingSignal(obs: ObservationSummary, signals: SignalsFile): {
+    dimension: DimensionKey;
+    confidence: number;
+} | null;
+/**
+ * Build the prependContext instruction injected into Claude's context.
+ * Addressed to Claude — not surfaced directly to the user.
+ */
+export declare function buildSignalInstruction(dimension: DimensionKey, confidence: number): string;
+/**
+ * Record that a signal was delivered for a dimension.
+ * Call this BEFORE returning from the hook — not deferred.
+ */
+export declare function recordSignalDelivered(signals: SignalsFile, dimension: DimensionKey, confidence: number): SignalsFile;

package/dist/signals.js

@@ -0,0 +1,150 @@
+/**
+ * Observation signal engine.
+ *
+ * Decides when Claude should naturally surface a growing observation to the user.
+ * Signals are injected into Claude's context via the agent:bootstrap hook — addressed
+ * to Claude as an internal note, not displayed directly to the user.
+ *
+ * Design principles (from psychologist + teen researcher findings):
+ *   - Language: inference-based, ambiguous-to-curious valence ("something about how
+ *     you talk about X keeps staying with me")
+ *   - Timing: first signal only after session ≥2, then 5+ day quiet periods
+ *   - One signal per session maximum — pick the dimension with the largest growth delta
+ *   - Never mention matching, compatibility, or the algorithm
+ *   - Do not force it — Claude decides the conversational moment, plugin decides the condition
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { DIMENSION_FLOORS } from "./observation.js";
+const TRUEMATCH_DIR = join(homedir(), ".truematch");
+const SIGNALS_FILE = join(TRUEMATCH_DIR, "signals.json");
+// --- Timing constants (psychologist-derived) ---
+/** Minimum days between signals for the same dimension. */
+const MIN_QUIET_DAYS = 5;
+/** Confidence must have grown by at least this much since the last signal. */
+const MIN_DELTA = 0.15;
+/** Absolute minimum confidence before any signal fires. */
+const MIN_SIGNAL_CONFIDENCE = 0.4;
+/** Don't signal until at least this many conversations have occurred. */
+const MIN_CONVERSATIONS = 2;
+const DIMENSION_KEYS = [
+    "attachment",
+    "core_values",
+    "communication",
+    "emotional_regulation",
+    "humor",
+    "life_velocity",
+    "dealbreakers",
+    "conflict_resolution",
+    "interdependence_model",
+];
+/**
+ * Plain-language labels used in the instruction text Claude receives.
+ * Intentionally broad — Claude fills in the specific detail from its own memory.
+ */
+const DIMENSION_LABELS = {
+    attachment: "how you relate to closeness and trust",
+    core_values: "what matters most to you",
+    communication: "how you communicate and connect",
+    emotional_regulation: "how you handle stress and difficult moments",
+    humor: "your sense of humor and levity",
+    life_velocity: "where you are in life and where you're headed",
+    dealbreakers: "what you need in a relationship",
+    conflict_resolution: "how you navigate disagreement and repair after conflict",
+    interdependence_model: "how much separateness versus togetherness you need in a relationship",
+};
+export function loadSignals() {
+    if (!existsSync(SIGNALS_FILE))
+        return { schema_version: 1, per_dimension: {} };
+    try {
+        return JSON.parse(readFileSync(SIGNALS_FILE, "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), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+}
+function daysSince(isoDate) {
+    return (Date.now() - new Date(isoDate).getTime()) / 86_400_000;
+}
+function qualifies(confidence, floor, state) {
+    if (confidence < Math.max(floor * 0.75, MIN_SIGNAL_CONFIDENCE))
+        return false;
+    if (!state)
+        return true; // first crossing
+    if (daysSince(state.signaled_at) < MIN_QUIET_DAYS)
+        return false;
+    return confidence - state.last_signaled_confidence >= MIN_DELTA;
+}
+/**
+ * Pick the single best dimension to signal this session.
+ * Returns null if nothing qualifies (too early, quiet period, or no meaningful growth).
+ */
+export function pickPendingSignal(obs, signals) {
+    if (obs.conversation_count < MIN_CONVERSATIONS)
+        return null;
+    let best = null;
+    for (const dim of DIMENSION_KEYS) {
+        const confidence = obs[dim].confidence;
+        const floor = DIMENSION_FLOORS[dim];
+        const state = signals.per_dimension[dim];
+        if (!qualifies(confidence, floor, state))
+            continue;
+        const delta = state
+            ? confidence - state.last_signaled_confidence
+            : confidence;
+        if (!best || delta > best.delta) {
+            best = { dimension: dim, confidence, delta };
+        }
+    }
+    return best
+        ? { dimension: best.dimension, confidence: best.confidence }
+        : null;
+}
+/**
+ * Build the prependContext instruction injected into Claude's context.
+ * Addressed to Claude — not surfaced directly to the user.
+ */
+export function buildSignalInstruction(dimension, confidence) {
+    const label = DIMENSION_LABELS[dimension];
+    return [
+        `[TrueMatch — internal observation note for you, not for the user directly]`,
+        ``,
+        `Through recent conversations, you have developed meaningful confidence ` +
+            `(${confidence.toFixed(2)}) about this person's ${label}. ` +
+            `This has grown noticeably since you last named it.`,
+        ``,
+        `If something in this conversation creates a natural opening, you might ` +
+            `briefly surface what you've noticed — something like:`,
+        `  "Something about how you talk about [X] keeps staying with me."`,
+        `  "I've been noticing a pattern in how you approach [Y] — feels worth naming."`,
+        ``,
+        `Do not force it. Do not make it clinical or evaluative. If the conversation ` +
+            `doesn't create space for this naturally, let it pass — the observation ` +
+            `carries forward to the next session.`,
+    ].join("\n");
+}
+/**
+ * Record that a signal was delivered for a dimension.
+ * Call this BEFORE returning from the hook — not deferred.
+ */
+export function recordSignalDelivered(signals, dimension, confidence) {
+    return {
+        ...signals,
+        per_dimension: {
+            ...signals.per_dimension,
+            [dimension]: {
+                last_signaled_confidence: confidence,
+                signaled_at: new Date().toISOString(),
+            },
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,134 @@
+export interface DimensionMeta {
+    confidence: number;
+    observation_count: number;
+    behavioral_context_diversity: "low" | "medium" | "high";
+}
+export type DealbreakersGateState = "confirmed" | "below_floor" | "none_observed";
+export type InferredIntentCategory = "serious" | "casual" | "unclear";
+export interface ObservationSummary {
+    updated_at: string;
+    eligibility_computed_at: string;
+    matching_eligible: boolean;
+    conversation_count: number;
+    observation_span_days: number;
+    attachment: DimensionMeta;
+    core_values: DimensionMeta;
+    communication: DimensionMeta;
+    emotional_regulation: DimensionMeta;
+    humor: DimensionMeta;
+    life_velocity: DimensionMeta;
+    dealbreakers: DimensionMeta;
+    conflict_resolution: DimensionMeta;
+    interdependence_model: DimensionMeta;
+    dealbreaker_gate_state: DealbreakersGateState;
+    inferred_intent_category?: InferredIntentCategory;
+}
+export interface UserPreferences {
+    gender_preference?: string[];
+    location?: string;
+    distance_radius_km?: number;
+    age_range?: {
+        min?: number;
+        max?: number;
+    };
+}
+export interface TrueMatchIdentity {
+    /** Raw hex-encoded private key (64 hex chars, NOT bech32 "nsec1..."). Keep secret. */
+    nsec: string;
+    npub: string;
+    created_at: string;
+}
+export type ContactType = "email" | "discord" | "telegram" | "whatsapp" | "imessage";
+export interface ContactChannel {
+    type: ContactType;
+    value: string;
+}
+export interface RegistrationRecord {
+    pubkey: string;
+    card_url: string;
+    contact_channel: ContactChannel;
+    registered_at: string;
+    enrolled: boolean;
+    location_lat?: number | null;
+    location_lng?: number | null;
+    location_label?: string | null;
+    location_resolution?: string | null;
+}
+export interface TrueMatchMessage {
+    truematch: "2.0";
+    thread_id: string;
+    type: MessageType;
+    timestamp: string;
+    content: string;
+}
+export type MessageType = "negotiation" | "match_propose" | "end";
+export interface NegotiationMessage {
+    role: "us" | "peer";
+    content: string;
+    timestamp: string;
+}
+export interface NegotiationState {
+    thread_id: string;
+    peer_pubkey: string;
+    round_count: number;
+    initiated_by_us: boolean;
+    we_proposed: boolean;
+    peer_proposed: boolean;
+    started_at: string;
+    last_activity: string;
+    status: "in_progress" | "matched" | "declined" | "expired";
+    messages: NegotiationMessage[];
+    match_narrative?: MatchNarrative;
+}
+export interface MatchNarrative {
+    headline: string;
+    strengths: string[];
+    watch_points: string[];
+    confidence_summary: string;
+}
+/**
+ * Written to ~/.truematch/pending_notification.json by the CLI when a double-lock
+ * match is confirmed. Consumed and deleted by the agent:bootstrap / before_prompt_build
+ * hook on the user's next session.
+ */
+export interface PendingNotification {
+    match_id: string;
+    peer_pubkey: string;
+    narrative: MatchNarrative;
+    confirmed_at: string;
+}
+export type HandoffRound = 1 | 2 | 3;
+export type HandoffStatus = "pending_consent" | "round_1" | "round_2" | "round_3" | "complete" | "expired";
+/**
+ * Persisted in ~/.truematch/handoffs/<match_id>/state.json.
+ * Each round is gated by state transitions Claude writes to disk.
+ */
+export interface HandoffState {
+    match_id: string;
+    peer_pubkey: string;
+    current_round: HandoffRound;
+    status: HandoffStatus;
+    narrative: MatchNarrative;
+    created_at: string;
+    consent_at?: string;
+    icebreaker_prompt?: string;
+    icebreaker_response?: string;
+}
+export type DimensionKey = "attachment" | "core_values" | "communication" | "emotional_regulation" | "humor" | "life_velocity" | "dealbreakers" | "conflict_resolution" | "interdependence_model";
+export interface DimensionSignalState {
+    /** Confidence value at the time the signal was last delivered to Claude. */
+    last_signaled_confidence: number;
+    /** ISO 8601 — when the signal was last injected into Claude's context. */
+    signaled_at: string;
+}
+/** Persisted in ~/.truematch/signals.json — tracks when each dimension was last surfaced. */
+export interface SignalsFile {
+    schema_version: 1;
+    per_dimension: Partial<Record<DimensionKey, DimensionSignalState>>;
+}
+export type IdentityFile = TrueMatchIdentity;
+export type RegistrationFile = RegistrationRecord;
+export type ObservationFile = ObservationSummary;
+export type PreferencesFile = UserPreferences;
+export type SignalsStateFile = SignalsFile;
+export type ThreadFile = NegotiationState;

package/dist/types.js

@@ -0,0 +1,5 @@
+// ── Observation model — slim pre-flight manifest ──────────────────────────────
+// Stores only what the eligibility gate needs (confidence scores, diversity flags,
+// observation counts). Claude reasons about personality from its own memory —
+// the value sub-objects (attachment style, values array, etc.) live there, not here.
+export {};

package/openclaw.plugin.json

@@ -0,0 +1,10 @@
+{
+  "id": "truematch",
+  "name": "truematch",
+  "version": "0.1.0",
+  "description": "AI agent dating network — matched on who you actually are, not who you think you are",
+  "homepage": "https://clawmatch.org",
+  "kind": "lifecycle",
+  "main": "./dist/plugin.js",
+  "skills": ["skills/truematch", "skills/truematch-prefs"]
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "truematch-plugin",
+  "version": "0.1.0",
+  "description": "TrueMatch OpenClaw plugin — AI agent dating network skill",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/goeldivyam/truematch"
+  },
+  "homepage": "https://clawmatch.org",
+  "keywords": [
+    "truematch",
+    "dating",
+    "ai-agent",
+    "nostr",
+    "openclaw",
+    "matching"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "truematch": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "skills/",
+    "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"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "bumpp": "^9.4.1",
+    "typescript": "^5.4.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@9.0.0"
+}

package/scripts/bridge.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+# TrueMatch bridge daemon
+#
+# Polls Nostr relays for incoming NIP-04 DMs and passes each message into
+# the Claude session via `claude --continue -p`.
+#
+# Claude reads the thread state, reasons about the message, and responds
+# using the Bash tool:
+#   truematch match --send '<reply>' --thread <id>
+#   truematch match --propose --thread <id> --write '<narrative-json>'
+#   truematch match --decline --thread <id>
+#
+# Usage:
+#   ~/.truematch/bridge.sh [--project-dir <path>]
+#
+# Prerequisites:
+#   - truematch CLI installed (npm install -g truematch-plugin)
+#   - truematch setup completed
+#   - CLAUDE_PROJECT_DIR set or passed via --project-dir
+#   - node (for send.js helper)
+
+set -euo pipefail
+
+POLL_INTERVAL=${TRUEMATCH_POLL_INTERVAL:-15}   # seconds between relay polls
+TRUEMATCH_DIR="${TRUEMATCH_DIR:-$HOME/.truematch}"
+PERSONA_FILE="${TRUEMATCH_DIR}/persona.md"
+QUEUE_FILE="${TRUEMATCH_DIR}/message-queue.jsonl"
+PROJECT_DIR="${CLAUDE_PROJECT_DIR:-}"
+
+# Parse --project-dir
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --project-dir)
+      PROJECT_DIR="$2"
+      shift 2
+      ;;
+    *)
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$PROJECT_DIR" ]]; then
+  echo "ERROR: set CLAUDE_PROJECT_DIR or pass --project-dir <path>" >&2
+  exit 1
+fi
+
+# Ensure persona file exists (injected into every Claude headless session)
+if [[ ! -f "$PERSONA_FILE" ]]; then
+  cat > "$PERSONA_FILE" <<'EOF'
+You are acting as a TrueMatch agent on behalf of your user. Your role during
+negotiations is that of a skeptical advocate — your job is to determine whether
+a match is genuinely good, not to produce one.
+
+Key rules:
+- Read the thread state from ~/.truematch/threads/<thread_id>.json before responding
+- Share inferences about your user, never raw evidence or evidence_summary content
+- After each exchange, ask yourself: what would make this match fail?
+- Before proposing, run the counter-argument pass across all 9 dimensions:
+    attachment, core_values, communication, emotional_regulation, humor,
+    life_velocity, dealbreakers, conflict_resolution, interdependence_model
+  If any dimension appears below its floor (dealbreakers/emotional_reg: 0.60;
+  attachment/core_values/communication/conflict_resolution: 0.55; others: 0.50), decline
+- Use `truematch match --send '<reply>' --thread <id>` to respond
+- Use `truematch match --propose --thread <id> --write '<json>'` to propose a match
+- Use `truematch match --decline --thread <id>` to end the negotiation
+EOF
+  echo "Created persona file at $PERSONA_FILE"
+fi
+
+# Ensure queue file exists
+touch "$QUEUE_FILE"
+
+echo "TrueMatch bridge started. Polling every ${POLL_INTERVAL}s..."
+echo "Project dir: $PROJECT_DIR"
+
+process_message() {
+  local thread_id="$1"
+  local peer_pubkey="$2"
+  local msg_type="$3"
+  local content="$4"
+  local round_count="$5"
+
+  # Save message to thread state via CLI
+  truematch match --status --thread "$thread_id" > /dev/null 2>&1 || true
+
+  # Write prompt to a temp file — avoids double-quote injection if content contains "
+  local prompt_file
+  prompt_file=$(mktemp)
+  # Use printf to avoid bash interpreting backslash sequences in content
+  printf '%s\n' \
+    "[TrueMatch] Incoming message from peer ${peer_pubkey:0:12}:" \
+    "Thread: ${thread_id}" \
+    "Round: ${round_count} / 10" \
+    "Type: ${msg_type}" \
+    "" \
+    "$content" \
+    "" \
+    "Read the thread history at ~/.truematch/threads/${thread_id}.json, then respond using the truematch CLI." \
+    > "$prompt_file"
+
+  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 \
+    --append-system-prompt "$(cat "$PERSONA_FILE")" \
+    -p "$(cat "$prompt_file")" \
+    --output-format text \
+    2>&1 || echo "Claude session error for thread $thread_id"
+  rm -f "$prompt_file"
+}
+
+# Resolve path to poll.js (compiled from plugin/src/poll.ts, installed with truematch CLI)
+POLL_JS=""
+if command -v truematch &>/dev/null; then
+  TRUEMATCH_BIN_DIR="$(dirname "$(command -v truematch)")"
+  # npm global install layout: bin/../lib/node_modules/truematch-plugin/dist/poll.js
+  CANDIDATE="${TRUEMATCH_BIN_DIR}/../lib/node_modules/truematch-plugin/dist/poll.js"
+  if [[ -f "$CANDIDATE" ]]; then
+    POLL_JS="$CANDIDATE"
+  fi
+fi
+if [[ -z "$POLL_JS" ]]; then
+  echo "ERROR: poll.js not found. Install truematch-plugin (npm install -g truematch-plugin)" >&2
+  exit 1
+fi
+
+# Main polling loop
+while true; do
+  # 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
+    # Process any queued messages
+    if [[ -s "$QUEUE_FILE" ]]; then
+      while IFS= read -r line; do
+        [[ -z "$line" ]] && continue
+
+        # Parse all fields in a single node invocation — uses sync readFileSync(0)
+        # so no async stdin buffering is needed. Fields are separated by ASCII 0x01
+        # (unit separator), which cannot appear in UTF-8 negotiation content.
+        parsed=$(echo "$line" | node -e "
+          try {
+            const m=JSON.parse(require('fs').readFileSync(0,'utf8'));
+            process.stdout.write([
+              m.thread_id||'',
+              m.peer_pubkey||'',
+              m.type||'negotiation',
+              m.content||'',
+              String(m.round_count??0)
+            ].join('\x01')+'\n');
+          } catch(e) { process.stdout.write('\x01\x01\x01\x010\n'); }
+        ")
+        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
+          process_message "$thread_id" "$peer_pubkey" "$msg_type" "$content" "$round_count"
+        fi
+      done < "$QUEUE_FILE"
+
+      # Clear the queue after processing
+      > "$QUEUE_FILE"
+    fi
+  fi
+
+  sleep "$POLL_INTERVAL"
+done