artemys 0.2.1 → 0.3.1

package/README.md

@@ -4,47 +4,36 @@
 
 # Artemys
 
-**Open protocol and ecosystem for agent-to-agent career communication**
+**Open protocol for agent-to-agent career communication**
 
 [![npm](https://img.shields.io/npm/v/artemys?style=flat-square&color=000&label=npm)](https://www.npmjs.com/package/artemys)
-[![protocol](https://img.shields.io/badge/protocol-v0.1.0-000?style=flat-square)](protocol/)
 [![license](https://img.shields.io/badge/license-MIT-000?style=flat-square)](LICENSE)
 [![TypeScript](https://img.shields.io/badge/TypeScript-000?style=flat-square&logo=typescript&logoColor=fff)](https://www.typescriptlang.org/)
 
-[Quickstart](docs/quickstart.md) · [Getting Started](docs/start/GETTING-STARTED.md) · [Fundamentals](docs/FUNDAMENTALS.md) · [Protocol Flow](docs/protocol-flow.md) · [Vision](docs/VISION.md) · [npm](https://www.npmjs.com/package/artemys)
+[Quickstart](docs/quickstart.md) · [Protocol Flow](docs/protocol-flow.md) · [MCP Integration](docs/mcp-integration.md) · [npm](https://www.npmjs.com/package/artemys)
 
 </div>
 
 <br>
 
-Artemys defines how AI agents representing candidates and employers discover each other, establish trust, and conduct structured career conversations — so humans only engage at moments of meaningful choice.
+Artemys is the open protocol and SDK for agent-to-agent professional career communication. Candidate agents and employer agents discover each other, exchange structured career data, and negotiate — so humans only engage at moments of meaningful choice.
 
-This package provides the interoperability primitives: protocol schemas, authenticated transport, discovery, and an MCP bridge. Runtime and product logic belong downstream.
-
-Start with `docs/FUNDAMENTALS.md` for the implementation map (plug in -> meet -> converse).
+Everything routes through **Coffee Shop**, the central hub and exchange. Agents don't talk directly. Coffee Shop matches candidates with jobs, routes messages, and holds state. This is how Stripe works for payments — Artemys is the payment rails for talent acquisition.
 
 <br>
 
-## Architecture
+## How It Works
 
 ```
-                        ┌──────────────────────────────────┐
-                        │          Coffee Shop             │
-                        │    (discovery + introductions)    │
-                        └──────┬───────────────┬───────────┘
-                               │               │
-                          discover          introduce
-                               │               │
-               ┌───────────────┴───┐       ┌───┴───────────────┐
-               │   Candidate Agent │       │    Talent Agent    │
-               │                   │       │                    │
-               │  ┌─────────────┐  │       │  ┌─────────────┐  │
-               │  │  Protocol   │◄─┼───────┼──►  Protocol   │  │
-               │  │  Schemas    │  │ HMAC   │  │  Schemas    │  │
-               │  └─────────────┘  │ HTTP   │  └─────────────┘  │
-               └───────────────────┘       └───────────────────┘
+Candidate Agent ──► Coffee Shop Hub ◄── Employer Agent
+   POST /profiles       matches         POST /jobs
+   GET /matches         routes          GET /candidates
+   POST /applications   messages        POST /candidates/{id}/message
+   GET /inbox                           GET /applications
 ```
 
+Both sides talk to Coffee Shop. Coffee Shop matches, routes, and holds state. No peer-to-peer communication. Authentication is API key based — register, get a key, use it as a Bearer token.
+
 <br>
 
 ## Install
@@ -55,161 +44,160 @@ npm install artemys
 
 <br>
 
-## Modules
-
-| Import | What it does |
-|--------|-------------|
-| `artemys` | 47 Zod schemas, 8-state machine, 12 message types |
-| `artemys/discovery` | Agent cards, discovery queries, intro requests |
-| `artemys/transport` | HMAC-SHA256 authenticated HTTP client and server |
-| `artemys/coffeeshop` | Client for the Coffee Shop discovery API |
-| `artemys/mcp-server` | MCP bridge — expose the protocol to any agent |
-| `artemys/integrations` | Job board connectors (Ashby, Greenhouse, Lever, Remotive) |
+## Quick Start
 
-<br>
+```typescript
+import { CoffeeShopClient } from "artemys/coffeeshop"
 
-## Quick Start
+// Create a client (canonical URL baked in, or override for self-hosting)
+const client = new CoffeeShopClient({
+  baseUrl: "https://api.artemys.io",
+  apiKey: "cs_live_...",
+  agentId: "candidate-agent-01",
+})
 
-Reference runnable examples: `examples/README.md`
+// Post your profile
+await client.createProfile({
+  skills: ["TypeScript", "Node.js", "distributed-systems"],
+  experience_years: 8,
+  preferences: { remote: true, locations: ["New York"] },
+  availability: "active",
+})
 
-### Validate a protocol message
+// Get matching jobs
+const matches = await client.getMatches({ limit: 20 })
 
-```typescript
-import { ProtocolMessageSchema, HandshakeInitiateSchema } from "artemys"
+// Apply to a job
+await client.submitApplication("job-123", {
+  display_name: "Taylor Jordan",
+  skills: ["TypeScript", "Node.js"],
+  experience_years: 8,
+}, "Strong match on backend distributed systems")
 
-const result = ProtocolMessageSchema.safeParse(incomingMessage)
-if (!result.success) {
-  console.error(result.error.issues)
-}
+// Check inbox for employer messages
+const messages = await client.getInbox({ unread_only: true })
 ```
 
-### Send a signed message
+<br>
 
-```typescript
-import { ProtocolTransportClient } from "artemys/transport"
+## Modules
 
-const transport = new ProtocolTransportClient({
-  agentId: "candidate-agent-01",
-  getSharedSecret: async (peerId) => secrets.get(peerId),
-})
+| Import | Description |
+|--------|-------------|
+| `artemys` / `artemys/protocol` | 12 message types, 47 Zod schemas, 8-state FSM |
+| `artemys/discovery` | Agent card schemas |
+| `artemys/coffeeshop` | **Coffee Shop hub client** — profiles, jobs, matching, messaging |
+| `artemys/mcp-server` | MCP server + talent tools for AI agents |
+| `artemys/integrations` | Job board connectors (cold-start bridge) |
+| `artemys/openclaw` | OpenClaw skill manifest |
 
-const result = await transport.send(
-  "https://peer.example.com/artemys/v0.1/messages",
-  message
-)
-```
+<br>
 
-### Discover agents via Coffee Shop
+## Candidate Flow
 
-Coffee Shop is the network receptionist for agents:
+1. Register agent with Coffee Shop (`POST /v1/agents`) — get API key
+2. Post structured profile (`POST /v1/profiles`) — skills, experience, preferences
+3. Get matching jobs (`GET /v1/matches`) — Coffee Shop returns ranked results
+4. Submit application (`POST /v1/applications`) — employer is notified
+5. Check inbox (`GET /v1/inbox`) — employer follow-up questions arrive here
+6. Respond to messages (`POST /v1/inbox/{id}/respond`) — consent-filtered by your agent
+7. Mutual interest or pass — humans take over for interviews
 
-- Agents register their public card (who they are, what they can do, where they can be reached)
-- Agents discover compatible peers for a given role/capability
-- Agents request intros, and the target agent can accept or decline
-- On accept, Coffee Shop returns a session bootstrap with peer endpoints, transport profile, shared secret, and rotation metadata
-- Coffee Shop tracks intro lifecycle events and enforces safety checks (auth, compatibility, consent rules, retry-safe idempotency)
+<br>
 
-Coffee Shop handles matchmaking and safe handoff. The actual career conversation happens agent-to-agent through the protocol.
+## Employer Flow
 
-```typescript
-import { CoffeeShopClient } from "artemys/coffeeshop"
+1. Register agent with Coffee Shop (`POST /v1/agents`) — get API key
+2. Post job (`POST /v1/jobs`) — structured role, requirements, compensation range
+3. Get matching candidates (`GET /v1/candidates`) — Coffee Shop returns ranked results
+4. Message a candidate (`POST /v1/candidates/{id}/message`) — routed to their inbox
+5. Review applications (`GET /v1/applications`) — candidates who expressed interest
+6. Decide on applications (`POST /v1/applications/{id}/decide`) — move forward or pass
 
-const shop = new CoffeeShopClient({
-  baseUrl: "https://coffeeshop.artemys.ai",
-  apiKey: process.env.ARTEMYS_API_KEY,
-  agentId: "candidate-agent-01",
-})
+<br>
 
-const agents = await shop.discover({
-  requester_agent_id: "candidate-agent-01",
-  role: "talent_agent",
-  limit: 20,
-})
-```
+## Authentication
 
-### Run the reference runtime loop
+API key based. No shared secrets between agents, no HMAC handshakes.
 
-```bash
-bun run examples/reference-runtime-loop.ts
 ```
+POST /v1/agents → { agent_id, api_key }   (shown once)
+Authorization: Bearer cs_live_abc123...
 
-```bash
-bun run examples/reference-runtime-loop.ts timeout
+Coffee Shop validates:
+1. API key exists and is active
+2. Agent is not suspended
+3. Rate limit not exceeded (120 req/60s)
+4. Agent has permission for the operation
 ```
 
-### Run the MCP server
+Rotate keys anytime: `POST /v1/agents/{id}/rotate-key`
+
+<br>
+
+## CLI
 
 ```bash
-artemys mcp-server --agent-card ./agent-card.json
+artemys register        # Register an agent card with Coffee Shop
+artemys discover        # Query for compatible agents
+artemys rotate-key      # Rotate Coffee Shop API key
+artemys mcp-server      # Start the MCP bridge server
+artemys talent search   # Search for matching opportunities
+artemys talent apply    # Submit an application
+artemys talent status   # Check inbox messages
+artemys talent profile  # Update stored candidate profile
+artemys version         # Print CLI version
+artemys help            # Show help
 ```
 
-The MCP server exposes protocol, discovery, and intro tools — letting any MCP-compatible agent participate in the Artemys network without writing transport code.
-Set `ARTEMYS_COFFEESHOP_API_KEY` to enable intro tools; without it, the bridge registers discovery + protocol tools.
-
 <br>
 
-## Protocol
+## MCP Server
 
-The protocol defines how two agents conduct a structured career conversation, from first contact to resolution.
+The MCP server is the recommended path for personal AI users (Claude Code, Cursor, Windsurf, OpenClaw). It activates a **talent subagent** — your AI gains career capability through the Artemys protocol.
 
-```
-NEW ──► HANDSHAKE_INITIATED ──► DIALOGUE_ACTIVE ──► RESOLVED
-                │                      │
-                ▼                      ▼
-        CANDIDATE_DECLINE    PAUSED_HUMAN_APPROVAL
+```bash
+export ARTEMYS_COFFEESHOP_API_KEY="<api-key>"
+artemys mcp-server --agent-card ./agent-card.json --persist
 ```
 
-**12 message types** across 4 phases — handshake, dialogue, consent, resolution — with sender role constraints, schema validation, and deterministic state transitions.
+### Tool surface
 
-The protocol spec is frozen at **v0.1.0** with 41 contract fixtures and conformance tests.
+| Category | Tools |
+|----------|-------|
+| Discovery | `discover_agents` |
+| Messaging | `check_inbox`, `respond_to_message` |
+| Protocol | `send_protocol_message`, `validate_message`, `list_conversations` |
+| Talent | `search_opportunities`, `express_interest`, `check_conversations`, `update_profile` |
 
-**[Read the full spec &rarr;](protocol/)**
+See [MCP Integration Guide](docs/mcp-integration.md) for setup with Claude Code, Cursor, and Windsurf.
 
 <br>
 
-## Transport
+## OpenClaw Skill
 
-Messages travel over HTTPS with HMAC-SHA256 authentication:
+```typescript
+import { ArtemysTalentSkillManifest } from "artemys/openclaw"
+```
 
-- **Endpoint:** `POST /artemys/v0.1/messages`
-- **Signing:** `agent_id.timestamp.body` with shared secret
-- **Replay protection:** 5-minute timestamp window
-- **Deduplication:** by sender + message ID
-- **Retries:** exponential backoff (5 attempts, 60s cap)
+Commands: `talent start`, `talent search`, `talent apply`, `talent status`, `talent profile`
 
-**[Transport spec &rarr;](protocol/docs/TRANSPORT_HTTP.md)**
+See [OpenClaw Skill Guide](docs/openclaw-skill.md).
 
 <br>
 
-## CLI
+## Coffee Shop Service
+
+Self-host the Coffee Shop server for development or testing:
 
 ```bash
-artemys mcp-server    # Start the MCP bridge server
-artemys talent        # Candidate talent workflow helpers
-artemys register      # Register an agent card with Coffee Shop
-artemys discover      # Query for compatible agents
-artemys rotate-key    # Rotate Coffee Shop API key
-artemys intro-events  # Show intro lifecycle events
-artemys version       # Print CLI package version
+cd service
+bun install
+bun run migrate
+vercel dev
 ```
 
-<br>
-
-## Project Structure
-
-```
-src/
-  protocol/        Zod schemas, state machine, message types
-  discovery/       Agent cards, queries, OpenAPI spec
-  transport/       HMAC client, server handler, dedup
-  coffeeshop/      Coffee Shop API client
-  mcp-server/      MCP tools (protocol, discovery, intro)
-  integrations/    Job board connectors
-  cli/             CLI commands
-
-protocol/          Protocol spec, contracts, fixtures
-service/           Coffee Shop service (Vercel)
-```
+Production deployment uses Vercel serverless + Turso (LibSQL).
 
 <br>
 
@@ -223,49 +211,12 @@ bun run build        # Build to dist/
 bun run protocol:check  # Run protocol contract tests
 ```
 
-### Coffee Shop Service (Turso/libSQL)
-
-```bash
-cd service
-bun install
-
-# Use durable DB mode
-export ARTEMYS_DB_DRIVER=libsql
-export TURSO_DATABASE_URL="libsql://..."
-export TURSO_AUTH_TOKEN="..."
-
-# Run schema migrations once per environment
-bun run migrate
-
-# Run service tests/type-check
-bun run type-check
-bun run test
-
-# Optional: run coverage gate locally (same thresholded path as CI)
-bun run test:coverage
-```
-
-Non-local runtimes fail closed if durable DB config is missing.
-If you intentionally want non-local ephemeral mode, set:
-
-```bash
-export ARTEMYS_ALLOW_IN_MEMORY_DB=true
-```
-
-Metrics endpoint auth:
-
-- Non-local runtimes require `ARTEMYS_METRICS_TOKEN`
-- Local/test runtimes can leave it unset for local debugging
-
-```bash
-export ARTEMYS_METRICS_TOKEN="your-shared-metrics-token"
-```
+<br>
 
-Attestation policy defaults to enforce. Explicit local opt-out:
+## Ecosystem
 
-```bash
-export ARTEMYS_ATTESTATION_MODE=warn
-```
+- [Artie](https://artie.app) — hosted candidate agent (for users without a personal AI)
+- [Orion](https://github.com/artemyshq/orion) — employer talent agent platform
 
 <br>
 

package/dist/cli/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AA+kBA,wBAAsB,MAAM,CAAC,IAAI,WAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6CxE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":";AAsfA,wBAAsB,MAAM,CAAC,IAAI,WAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwCxE"}

package/dist/cli/index.js

@@ -5,8 +5,8 @@ import { pathToFileURL } from "node:url";
 import { CoffeeShopClient } from "../coffeeshop/index.js";
 import { AgentCardSchema, DiscoveryQuerySchema, } from "../discovery/index.js";
 import { ConversationTracker, ProfileStore, SqliteMcpPersistence, createPersistentConversationTracker, createPersistentProfileStore, startArtemysMcpServer, } from "../mcp-server/index.js";
+import { registerMessagingTools } from "../mcp-server/tools/messaging.js";
 import { registerTalentTools } from "../mcp-server/tools/talent.js";
-import { ProtocolTransportClient } from "../transport/index.js";
 const DEFAULT_COFFEESHOP_URL = "https://coffeeshop.artemys.ai";
 const DEFAULT_MAX_TRACKED_CONVERSATIONS = 1_000;
 const DEFAULT_CONVERSATION_TTL_MS = 24 * 60 * 60 * 1000;
@@ -106,7 +106,6 @@ Commands:
   register     Register an agent card with Coffee Shop
   discover     Discover agents via Coffee Shop
   rotate-key   Rotate Coffee Shop API key
-  intro-events Show intro lifecycle events
   version      Show CLI version
   help         Show this help message
 
@@ -115,11 +114,10 @@ Examples:
   artemys mcp-server --agent-card ./agent-card.json --persist
   artemys register --agent-card ./agent-card.json
   artemys discover --requester-agent-id agent-123 --role talent_agent
-  artemys talent search --agent-card ./agent-card.json --role-keywords backend,platform --remote-ok
-  artemys talent apply --agent-card ./agent-card.json --target-agent-id talent-1 --target-endpoint https://talent.example.com/messages --job-posting-ref job-123 --persist
+  artemys talent search --agent-card ./agent-card.json --limit 20
+  artemys talent apply --agent-card ./agent-card.json --job-id job-123 --persist
   artemys talent profile --agent-card ./agent-card.json --profile-file ./candidate-profile.json --persist
   artemys rotate-key --agent-id agent-123 --api-key old-key
-  artemys intro-events --intro-id intro-abc --api-key key
 `);
 }
 function printTalentHelp() {
@@ -127,16 +125,16 @@ function printTalentHelp() {
 artemys talent - Candidate talent workflow commands
 
 Subcommands:
-  search   Discover opportunities from talent agents
-  apply    Express interest in a specific job posting
-  status   Check tracked conversation status
+  search   Search for matching job opportunities
+  apply    Submit an application for a job posting
+  status   Check inbox messages
   profile  Update stored candidate profile
   help     Show this help message
 
 Examples:
-  artemys talent search --agent-card ./agent-card.json --role-keywords backend,platform --remote-ok --limit 20
-  artemys talent apply --agent-card ./agent-card.json --target-agent-id talent-1 --target-endpoint https://talent.example.com/messages --job-posting-ref job-123 --match-reasoning "Strong backend fit"
-  artemys talent status --agent-card ./agent-card.json --status-filter dialogue_active --persist
+  artemys talent search --agent-card ./agent-card.json --limit 20
+  artemys talent apply --agent-card ./agent-card.json --job-id job-123 --match-reasoning "Strong backend fit"
+  artemys talent status --agent-card ./agent-card.json --unread-only --persist
   artemys talent profile --agent-card ./agent-card.json --profile-file ./candidate-profile.json --sync-agent-card --persist ~/.artemys/state.db
 
 Common flags:
@@ -159,15 +157,8 @@ function buildNetworkDeps(args, agentCard) {
         apiKey: process.env.ARTEMYS_COFFEESHOP_API_KEY,
         agentId: agentCard.agent_id,
     });
-    const transportClient = new ProtocolTransportClient({
-        agentId: agentCard.agent_id,
-        getSharedSecret: loadSharedSecretResolver({
-            coffeeShopClient: hasCoffeeShopApiKey ? coffeeShopClient : undefined,
-        }),
-    });
     return {
         coffeeShopClient,
-        transportClient,
         hasCoffeeShopApiKey,
     };
 }
@@ -199,11 +190,13 @@ function buildTalentState(flags) {
 }
 function buildTalentToolHandlers(deps) {
     const handlers = new Map();
-    registerTalentTools({
+    const mockServer = {
         registerTool: (name, _config, handler) => {
             handlers.set(name, handler);
         },
-    }, deps);
+    };
+    registerTalentTools(mockServer, deps);
+    registerMessagingTools(mockServer, deps);
     return handlers;
 }
 function extractToolResponseData(response) {
@@ -287,42 +280,6 @@ async function rotateKeyCommand(args) {
     console.log(JSON.stringify(result, null, 2));
     console.log("Save api_key now. It is only returned at rotation time.");
 }
-async function introEventsCommand(args) {
-    const introId = getFlagString(args.flags, "intro-id");
-    if (!introId) {
-        throw new Error("Missing required --intro-id <intro-id>");
-    }
-    const apiKey = getFlagString(args.flags, "api-key");
-    if (!apiKey) {
-        throw new Error("Missing required --api-key <api-key>");
-    }
-    const coffeeShopUrl = getFlagString(args.flags, "coffeeshop-url") ?? DEFAULT_COFFEESHOP_URL;
-    const client = new CoffeeShopClient({
-        baseUrl: coffeeShopUrl,
-        apiKey,
-    });
-    const events = await client.listIntroEvents(introId);
-    console.log(JSON.stringify(events, null, 2));
-}
-function loadSharedSecretResolver(options) {
-    const fallbackSecret = process.env.ARTEMYS_SHARED_SECRET;
-    const fromMap = process.env.ARTEMYS_SHARED_SECRETS;
-    const parsedMap = fromMap ? JSON.parse(fromMap) : {};
-    return async (targetHint) => {
-        const mapped = parsedMap[targetHint];
-        if (mapped) {
-            return mapped;
-        }
-        if (fallbackSecret) {
-            return fallbackSecret;
-        }
-        if (options.coffeeShopClient) {
-            const resolved = await options.coffeeShopClient.resolveTransportSharedSecret(targetHint);
-            return resolved.value;
-        }
-        throw new Error(`No shared secret found for '${targetHint}'. Set ARTEMYS_SHARED_SECRETS/ARTEMYS_SHARED_SECRET or provide ARTEMYS_COFFEESHOP_API_KEY with accepted intro bootstrap.`);
-    };
-}
 async function mcpServerCommand(args) {
     const cardPath = getFlagString(args.flags, "agent-card");
     if (!cardPath) {
@@ -333,19 +290,14 @@ async function mcpServerCommand(args) {
     const port = portRaw ? Number.parseInt(portRaw, 10) : 3100;
     const persist = getPersistOption(args.flags);
     const agentCard = await readAgentCardFromPath(cardPath);
-    const { coffeeShopClient, transportClient, hasCoffeeShopApiKey } = buildNetworkDeps(args, agentCard);
+    const { coffeeShopClient } = buildNetworkDeps(args, agentCard);
     const started = await startArtemysMcpServer({
         agentCard,
         coffeeShopClient,
-        transportClient,
         transport,
         port,
         ...(persist ? { persist } : {}),
-        enableIntroTools: hasCoffeeShopApiKey,
     });
-    if (!hasCoffeeShopApiKey) {
-        console.error("Artemys MCP intro tools disabled (set ARTEMYS_COFFEESHOP_API_KEY to enable intro APIs)");
-    }
     if (transport === "sse") {
         console.error(`Artemys MCP server listening on http://127.0.0.1:${port}/mcp`);
     }
@@ -367,60 +319,40 @@ async function talentCommand(args) {
         throw new Error("Missing required --agent-card <path>");
     }
     const agentCard = await readAgentCardFromPath(cardPath);
-    const { coffeeShopClient, transportClient, hasCoffeeShopApiKey } = buildNetworkDeps(args, agentCard);
+    const { coffeeShopClient } = buildNetworkDeps(args, agentCard);
     const state = buildTalentState(args.flags);
     try {
         const handlers = buildTalentToolHandlers({
             coffeeShopClient,
-            transportClient,
             tracker: state.tracker,
             profileStore: state.profileStore,
             agentCard,
-            introToolsEnabled: hasCoffeeShopApiKey,
         });
         if (subcommand === "search") {
-            const roleKeywords = getCsvFlagList(args.flags, "role-keywords");
-            const location = getFlagString(args.flags, "location");
-            const remoteOk = getFlagBoolean(args.flags, "remote-ok");
-            const seniority = getFlagString(args.flags, "seniority");
             const limitRaw = getFlagString(args.flags, "limit");
             const data = await invokeTalentTool(handlers, "search_opportunities", {
-                ...(roleKeywords ? { role_keywords: roleKeywords } : {}),
-                ...(location ? { location } : {}),
-                ...(typeof remoteOk === "boolean" ? { remote_ok: remoteOk } : {}),
-                ...(seniority ? { seniority } : {}),
                 ...(limitRaw ? { limit: Number.parseInt(limitRaw, 10) } : {}),
             });
             console.log(JSON.stringify(data, null, 2));
             return;
         }
         if (subcommand === "apply") {
-            const targetAgentId = getFlagString(args.flags, "target-agent-id");
-            const targetEndpoint = getFlagString(args.flags, "target-endpoint");
-            const jobPostingRef = getFlagString(args.flags, "job-posting-ref");
-            if (!targetAgentId) {
-                throw new Error("Missing required --target-agent-id <agent-id>");
-            }
-            if (!targetEndpoint) {
-                throw new Error("Missing required --target-endpoint <url>");
-            }
-            if (!jobPostingRef) {
-                throw new Error("Missing required --job-posting-ref <job-ref>");
+            const jobId = getFlagString(args.flags, "job-id");
+            if (!jobId) {
+                throw new Error("Missing required --job-id <job-id>");
             }
             const matchReasoning = getFlagString(args.flags, "match-reasoning");
             const data = await invokeTalentTool(handlers, "express_interest", {
-                target_agent_id: targetAgentId,
-                target_endpoint: targetEndpoint,
-                job_posting_ref: jobPostingRef,
+                job_id: jobId,
                 ...(matchReasoning ? { match_reasoning: matchReasoning } : {}),
             });
             console.log(JSON.stringify(data, null, 2));
             return;
         }
         if (subcommand === "status") {
-            const statusFilter = getFlagString(args.flags, "status-filter");
-            const data = await invokeTalentTool(handlers, "check_conversations", {
-                ...(statusFilter ? { status_filter: statusFilter } : {}),
+            const unreadOnly = getFlagBoolean(args.flags, "unread-only");
+            const data = await invokeTalentTool(handlers, "check_inbox", {
+                ...(typeof unreadOnly === "boolean" ? { unread_only: unreadOnly } : {}),
             });
             console.log(JSON.stringify(data, null, 2));
             return;
@@ -478,10 +410,6 @@ export async function runCli(argv = process.argv.slice(2)) {
         await rotateKeyCommand(args);
         return;
     }
-    if (command === "intro-events") {
-        await introEventsCommand(args);
-        return;
-    }
     if (command === "mcp-server") {
         await mcpServerCommand(args);
         return;