@crmy/cli 0.5.2 → 0.5.4

package/dist/index.js

@@ -1 +1,2040 @@
 #!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command27 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+function initCommand() {
+  return new Command("init").description("Initialize crmy.ai: configure database, run migrations, create user").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    console.log("\n  crmy.ai \u2014 Agent-first CRM setup\n");
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "databaseUrl",
+        message: "PostgreSQL URL?",
+        default: "postgresql://localhost:5432/crmy"
+      },
+      {
+        type: "input",
+        name: "name",
+        message: "Your name?"
+      },
+      {
+        type: "input",
+        name: "email",
+        message: "Your email?"
+      },
+      {
+        type: "password",
+        name: "password",
+        message: "Password?",
+        mask: "*"
+      }
+    ]);
+    process.env.CRMY_IMPORTED = "1";
+    try {
+      const { initPool, closePool } = await import("@crmy/server");
+      const { runMigrations } = await import("@crmy/server");
+      console.log("\nConnecting to database...");
+      const db = await initPool(answers.databaseUrl);
+      console.log("Connected.");
+      console.log("Running migrations...");
+      const ran = await runMigrations(db);
+      if (ran.length > 0) {
+        console.log(`  Ran ${ran.length} migration(s): ${ran.join(", ")}`);
+      } else {
+        console.log("  No pending migrations.");
+      }
+      const tenantResult = await db.query(
+        `INSERT INTO tenants (slug, name) VALUES ('default', 'Default Tenant')
+           ON CONFLICT (slug) DO UPDATE SET name = 'Default Tenant'
+           RETURNING id`
+      );
+      const tenantId = tenantResult.rows[0].id;
+      const passwordHash = crypto.createHash("sha256").update(answers.password).digest("hex");
+      const userResult = await db.query(
+        `INSERT INTO users (tenant_id, email, name, role, password_hash)
+           VALUES ($1, $2, $3, 'owner', $4)
+           ON CONFLICT (tenant_id, email) DO UPDATE SET name = $3, password_hash = $4
+           RETURNING id`,
+        [tenantId, answers.email, answers.name, passwordHash]
+      );
+      const userId = userResult.rows[0].id;
+      const rawKey = "crmy_" + crypto.randomBytes(32).toString("hex");
+      const keyHash = crypto.createHash("sha256").update(rawKey).digest("hex");
+      await db.query(
+        `INSERT INTO api_keys (tenant_id, user_id, key_hash, label, scopes)
+           VALUES ($1, $2, $3, 'default', '{read,write,admin}')`,
+        [tenantId, userId, keyHash]
+      );
+      const jwtSecret = crypto.randomBytes(32).toString("hex");
+      const config = {
+        serverUrl: "http://localhost:3000",
+        apiKey: rawKey,
+        tenantId: "default",
+        database: {
+          url: answers.databaseUrl
+        },
+        jwtSecret,
+        hitl: {
+          requireApproval: ["bulk_update", "bulk_delete", "send_email"],
+          autoApproveSeconds: 0
+        }
+      };
+      const configPath = path.join(process.cwd(), ".crmy.json");
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+      const gitignorePath = path.join(process.cwd(), ".gitignore");
+      const gitignoreContent = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf-8") : "";
+      if (!gitignoreContent.includes(".crmy.json")) {
+        fs.appendFileSync(gitignorePath, "\n.crmy.json\n");
+      }
+      await closePool();
+      console.log("\n  \u2713 crmy.ai initialized\n");
+      console.log("  Add to Claude Code:");
+      console.log("  claude mcp add crmy -- npx crmy mcp\n");
+      console.log("  Or start the server:");
+      console.log("  npx crmy server\n");
+    } catch (err) {
+      console.error("\nSetup failed:", err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/server.ts
+import { Command as Command2 } from "commander";
+
+// src/config.ts
+import fs2 from "fs";
+import path2 from "path";
+import os from "os";
+var AUTH_DIR = path2.join(os.homedir(), ".crmy");
+var AUTH_FILE = path2.join(AUTH_DIR, "auth.json");
+function loadConfigFile() {
+  const configPath = path2.join(process.cwd(), ".crmy.json");
+  try {
+    const raw = fs2.readFileSync(configPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function loadAuthState() {
+  try {
+    const raw = fs2.readFileSync(AUTH_FILE, "utf-8");
+    const state = JSON.parse(raw);
+    if (state.expiresAt && new Date(state.expiresAt) < /* @__PURE__ */ new Date()) {
+      return null;
+    }
+    return state;
+  } catch {
+    return null;
+  }
+}
+function saveAuthState(state) {
+  fs2.mkdirSync(AUTH_DIR, { recursive: true });
+  fs2.writeFileSync(AUTH_FILE, JSON.stringify(state, null, 2) + "\n", { mode: 384 });
+}
+function clearAuthState() {
+  try {
+    fs2.unlinkSync(AUTH_FILE);
+  } catch {
+  }
+}
+function resolveServerUrl() {
+  return process.env.CRMY_SERVER_URL ?? loadAuthState()?.serverUrl ?? loadConfigFile().serverUrl;
+}
+
+// src/commands/server.ts
+function serverCommand() {
+  return new Command2("server").description("Start the crmy HTTP server").option("--port <port>", "HTTP port", "3000").action(async (opts) => {
+    const config = loadConfigFile();
+    process.env.DATABASE_URL = config.database?.url ?? process.env.DATABASE_URL;
+    process.env.JWT_SECRET = config.jwtSecret ?? process.env.JWT_SECRET ?? "dev-secret";
+    process.env.PORT = opts.port;
+    process.env.CRMY_IMPORTED = "1";
+    if (!process.env.DATABASE_URL) {
+      console.error("No database URL. Run `crmy init` first or set DATABASE_URL.");
+      process.exit(1);
+    }
+    const { createApp, loadConfig } = await import("@crmy/server");
+    const serverConfig = loadConfig();
+    const { app } = await createApp(serverConfig);
+    app.listen(serverConfig.port, () => {
+      console.log(`crmy server ready on :${serverConfig.port}`);
+    });
+  });
+}
+
+// src/commands/mcp.ts
+import { Command as Command3 } from "commander";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+function mcpCommand() {
+  return new Command3("mcp").description("Start stdio MCP server (for Claude Code)").action(async () => {
+    const config = loadConfigFile();
+    const databaseUrl = process.env.DATABASE_URL ?? config.database?.url;
+    const apiKey = process.env.CRMY_API_KEY ?? config.apiKey;
+    if (!databaseUrl) {
+      console.error("No database URL. Run `crmy init` first or set DATABASE_URL.");
+      process.exit(1);
+    }
+    process.env.CRMY_IMPORTED = "1";
+    const { initPool, createMcpServer } = await import("@crmy/server");
+    const { runMigrations } = await import("@crmy/server");
+    const db = await initPool(databaseUrl);
+    await runMigrations(db);
+    let actor = {
+      tenant_id: "",
+      actor_id: "cli-agent",
+      actor_type: "agent",
+      role: "owner"
+    };
+    if (apiKey) {
+      const crypto2 = await import("crypto");
+      const keyHash = crypto2.createHash("sha256").update(apiKey).digest("hex");
+      const result = await db.query(
+        `SELECT ak.tenant_id, ak.user_id, ak.scopes, u.role
+           FROM api_keys ak LEFT JOIN users u ON ak.user_id = u.id
+           WHERE ak.key_hash = $1`,
+        [keyHash]
+      );
+      if (result.rows.length > 0) {
+        const row = result.rows[0];
+        actor = {
+          tenant_id: row.tenant_id,
+          actor_id: row.user_id ?? "api-key-agent",
+          actor_type: "agent",
+          role: row.role ?? "member"
+        };
+      }
+    }
+    if (!actor.tenant_id) {
+      const tenantResult = await db.query("SELECT id FROM tenants WHERE slug = 'default' LIMIT 1");
+      if (tenantResult.rows.length > 0) {
+        actor.tenant_id = tenantResult.rows[0].id;
+      }
+    }
+    const server = createMcpServer(db, () => actor);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+  });
+}
+
+// src/commands/contacts.ts
+import { Command as Command4 } from "commander";
+
+// src/client.ts
+var TOOL_REST_MAP = {
+  // Contacts
+  contact_create: { method: "POST", path: () => "/api/v1/contacts" },
+  contact_get: { method: "GET", path: (i) => `/api/v1/contacts/${i.id}` },
+  contact_search: { method: "GET", path: (i) => `/api/v1/contacts?q=${encodeURIComponent(i.query ?? "")}&limit=${i.limit ?? 20}${i.lifecycle_stage ? `&stage=${i.lifecycle_stage}` : ""}${i.cursor ? `&cursor=${i.cursor}` : ""}` },
+  contact_update: { method: "PATCH", path: (i) => `/api/v1/contacts/${i.id}` },
+  contact_set_lifecycle: { method: "PATCH", path: (i) => `/api/v1/contacts/${i.id}` },
+  contact_log_activity: { method: "POST", path: () => "/api/v1/activities" },
+  contact_get_timeline: { method: "GET", path: (i) => `/api/v1/contacts/${i.id}/timeline` },
+  // Accounts
+  account_create: { method: "POST", path: () => "/api/v1/accounts" },
+  account_get: { method: "GET", path: (i) => `/api/v1/accounts/${i.id}` },
+  account_search: { method: "GET", path: (i) => `/api/v1/accounts?q=${encodeURIComponent(i.query ?? "")}&limit=${i.limit ?? 20}` },
+  account_update: { method: "PATCH", path: (i) => `/api/v1/accounts/${i.id}` },
+  // Opportunities
+  opportunity_create: { method: "POST", path: () => "/api/v1/opportunities" },
+  opportunity_get: { method: "GET", path: (i) => `/api/v1/opportunities/${i.id}` },
+  opportunity_search: { method: "GET", path: (i) => `/api/v1/opportunities?q=${encodeURIComponent(i.query ?? "")}&limit=${i.limit ?? 20}${i.stage ? `&stage=${i.stage}` : ""}` },
+  opportunity_advance_stage: { method: "PATCH", path: (i) => `/api/v1/opportunities/${i.id}` },
+  opportunity_update: { method: "PATCH", path: (i) => `/api/v1/opportunities/${i.id}` },
+  // Activities
+  activity_create: { method: "POST", path: () => "/api/v1/activities" },
+  activity_get: { method: "GET", path: (i) => `/api/v1/activities?limit=${i.limit ?? 20}` },
+  activity_search: { method: "GET", path: (i) => `/api/v1/activities?limit=${i.limit ?? 20}` },
+  // Use Cases
+  use_case_create: { method: "POST", path: () => "/api/v1/use-cases" },
+  use_case_get: { method: "GET", path: (i) => `/api/v1/use-cases/${i.id}` },
+  use_case_search: { method: "GET", path: (i) => `/api/v1/use-cases?q=${encodeURIComponent(i.query ?? "")}&limit=${i.limit ?? 20}${i.stage ? `&stage=${i.stage}` : ""}${i.account_id ? `&account_id=${i.account_id}` : ""}` },
+  use_case_update: { method: "PATCH", path: (i) => `/api/v1/use-cases/${i.id}` },
+  use_case_delete: { method: "DELETE", path: (i) => `/api/v1/use-cases/${i.id}` },
+  use_case_advance_stage: { method: "POST", path: (i) => `/api/v1/use-cases/${i.id}/stage` },
+  use_case_update_consumption: { method: "POST", path: (i) => `/api/v1/use-cases/${i.id}/consumption` },
+  use_case_set_health: { method: "POST", path: (i) => `/api/v1/use-cases/${i.id}/health` },
+  use_case_link_contact: { method: "POST", path: (i) => `/api/v1/use-cases/${i.use_case_id ?? i.id}/contacts` },
+  use_case_unlink_contact: { method: "DELETE", path: (i) => `/api/v1/use-cases/${i.use_case_id ?? i.id}/contacts/${i.contact_id}` },
+  use_case_list_contacts: { method: "GET", path: (i) => `/api/v1/use-cases/${i.use_case_id ?? i.id}/contacts` },
+  use_case_get_timeline: { method: "GET", path: (i) => `/api/v1/use-cases/${i.id}/timeline` },
+  use_case_summary: { method: "GET", path: (i) => `/api/v1/analytics/use-cases?group_by=${i.group_by ?? "stage"}` },
+  // Analytics
+  pipeline_summary: { method: "GET", path: (i) => `/api/v1/analytics/pipeline${i.owner_id ? `?owner_id=${i.owner_id}` : ""}` },
+  pipeline_forecast: { method: "GET", path: (i) => `/api/v1/analytics/forecast${i.period ? `?period=${i.period}` : ""}` },
+  // HITL
+  hitl_list_pending: { method: "GET", path: () => "/api/v1/hitl" },
+  hitl_check_status: { method: "GET", path: (i) => `/api/v1/hitl/${i.id}` },
+  hitl_submit_request: { method: "POST", path: () => "/api/v1/hitl" },
+  hitl_resolve: { method: "POST", path: (i) => `/api/v1/hitl/${i.id}/resolve` },
+  // Webhooks
+  webhook_create: { method: "POST", path: () => "/api/v1/webhooks" },
+  webhook_list: { method: "GET", path: () => "/api/v1/webhooks" },
+  webhook_get: { method: "GET", path: (i) => `/api/v1/webhooks/${i.id}` },
+  webhook_update: { method: "PATCH", path: (i) => `/api/v1/webhooks/${i.id}` },
+  webhook_delete: { method: "DELETE", path: (i) => `/api/v1/webhooks/${i.id}` },
+  webhook_list_deliveries: { method: "GET", path: (i) => `/api/v1/webhooks/${i.endpoint_id ?? i.id}/deliveries` },
+  // Emails
+  email_create: { method: "POST", path: () => "/api/v1/emails" },
+  email_get: { method: "GET", path: (i) => `/api/v1/emails/${i.id}` },
+  email_search: { method: "GET", path: (i) => `/api/v1/emails?limit=${i.limit ?? 20}` },
+  // Custom Fields
+  custom_field_create: { method: "POST", path: () => "/api/v1/custom-fields" },
+  custom_field_list: { method: "GET", path: (i) => `/api/v1/custom-fields?object_type=${i.object_type}` },
+  custom_field_delete: { method: "DELETE", path: (i) => `/api/v1/custom-fields/${i.id}` },
+  // Notes
+  note_create: { method: "POST", path: () => "/api/v1/notes" },
+  note_get: { method: "GET", path: (i) => `/api/v1/notes/${i.id}` },
+  note_list: { method: "GET", path: (i) => `/api/v1/notes?object_type=${i.object_type}&object_id=${i.object_id}` },
+  note_delete: { method: "DELETE", path: (i) => `/api/v1/notes/${i.id}` },
+  // Workflows
+  workflow_create: { method: "POST", path: () => "/api/v1/workflows" },
+  workflow_get: { method: "GET", path: (i) => `/api/v1/workflows/${i.id}` },
+  workflow_list: { method: "GET", path: () => "/api/v1/workflows" },
+  workflow_delete: { method: "DELETE", path: (i) => `/api/v1/workflows/${i.id}` },
+  workflow_run_list: { method: "GET", path: (i) => `/api/v1/workflows/${i.workflow_id ?? i.id}/runs` },
+  // Events
+  event_search: { method: "GET", path: (i) => `/api/v1/events?${i.object_id ? `object_id=${i.object_id}&` : ""}limit=${i.limit ?? 20}` },
+  // Search
+  search: { method: "GET", path: (i) => `/api/v1/search?q=${encodeURIComponent(i.query ?? "")}` },
+  // Meta
+  schema_get: { method: "GET", path: () => "/health" },
+  tenant_get_stats: { method: "GET", path: () => "/health" },
+  // Actors
+  actor_register: { method: "POST", path: () => "/api/v1/actors" },
+  actor_get: { method: "GET", path: (i) => `/api/v1/actors/${i.id}` },
+  actor_list: { method: "GET", path: (i) => `/api/v1/actors?limit=${i.limit ?? 20}${i.actor_type ? `&actor_type=${i.actor_type}` : ""}${i.query ? `&q=${encodeURIComponent(i.query)}` : ""}` },
+  actor_update: { method: "PATCH", path: (i) => `/api/v1/actors/${i.id}` },
+  actor_whoami: { method: "GET", path: () => "/api/v1/actors/whoami" },
+  // Assignments
+  assignment_create: { method: "POST", path: () => "/api/v1/assignments" },
+  assignment_get: { method: "GET", path: (i) => `/api/v1/assignments/${i.id}` },
+  assignment_list: { method: "GET", path: (i) => `/api/v1/assignments?limit=${i.limit ?? 20}${i.assigned_to ? `&assigned_to=${i.assigned_to}` : ""}${i.assigned_by ? `&assigned_by=${i.assigned_by}` : ""}${i.status ? `&status=${i.status}` : ""}` },
+  assignment_update: { method: "PATCH", path: (i) => `/api/v1/assignments/${i.id}` },
+  assignment_accept: { method: "POST", path: (i) => `/api/v1/assignments/${i.id}/accept` },
+  assignment_complete: { method: "POST", path: (i) => `/api/v1/assignments/${i.id}/complete` },
+  assignment_decline: { method: "POST", path: (i) => `/api/v1/assignments/${i.id}/decline` },
+  // Context Entries
+  context_add: { method: "POST", path: () => "/api/v1/context" },
+  context_get: { method: "GET", path: (i) => `/api/v1/context/${i.id}` },
+  context_list: { method: "GET", path: (i) => `/api/v1/context?limit=${i.limit ?? 20}${i.subject_type ? `&subject_type=${i.subject_type}` : ""}${i.subject_id ? `&subject_id=${i.subject_id}` : ""}${i.context_type ? `&context_type=${i.context_type}` : ""}` },
+  context_supersede: { method: "POST", path: (i) => `/api/v1/context/${i.id}/supersede` },
+  context_search: { method: "GET", path: (i) => `/api/v1/context/search?q=${encodeURIComponent(i.query)}&limit=${i.limit ?? 20}${i.subject_type ? `&subject_type=${i.subject_type}` : ""}${i.context_type ? `&context_type=${i.context_type}` : ""}${i.tag ? `&tag=${i.tag}` : ""}${i.current_only === false ? "&current_only=false" : ""}` },
+  context_review: { method: "POST", path: (i) => `/api/v1/context/${i.id}/review` },
+  context_stale: { method: "GET", path: (i) => `/api/v1/context/stale?limit=${i.limit ?? 20}${i.subject_type ? `&subject_type=${i.subject_type}` : ""}${i.subject_id ? `&subject_id=${i.subject_id}` : ""}` },
+  // Activity Type Registry
+  activity_type_list: { method: "GET", path: (i) => `/api/v1/activity-types${i.category ? `?category=${i.category}` : ""}` },
+  activity_type_add: { method: "POST", path: () => "/api/v1/activity-types" },
+  activity_type_remove: { method: "DELETE", path: (i) => `/api/v1/activity-types/${i.type_name}` },
+  // Context Type Registry
+  context_type_list: { method: "GET", path: () => "/api/v1/context-types" },
+  context_type_add: { method: "POST", path: () => "/api/v1/context-types" },
+  context_type_remove: { method: "DELETE", path: (i) => `/api/v1/context-types/${i.type_name}` },
+  // Briefing
+  briefing_get: { method: "GET", path: (i) => `/api/v1/briefing/${i.subject_type}/${i.subject_id}?format=${i.format ?? "json"}${i.since ? `&since=${i.since}` : ""}${i.include_stale ? "&include_stale=true" : ""}${i.context_types ? `&context_types=${i.context_types.join(",")}` : ""}` },
+  // Assignment: Start, Block, Cancel
+  assignment_start: { method: "POST", path: (i) => `/api/v1/assignments/${i.id}/start` },
+  assignment_block: { method: "POST", path: (i) => `/api/v1/assignments/${i.id}/block` },
+  assignment_cancel: { method: "POST", path: (i) => `/api/v1/assignments/${i.id}/cancel` },
+  // Activity Timeline (enhanced)
+  activity_get_timeline: { method: "GET", path: (i) => `/api/v1/activities?subject_type=${i.subject_type}&subject_id=${i.subject_id}&limit=${i.limit ?? 50}` }
+};
+function createHttpClient(serverUrl, token) {
+  return {
+    async call(toolName, input) {
+      const mapping = TOOL_REST_MAP[toolName];
+      if (!mapping) {
+        throw new Error(`Unknown tool: ${toolName} (no REST mapping)`);
+      }
+      const { method, path: path3 } = mapping;
+      const url = `${serverUrl.replace(/\/$/, "")}${path3(input)}`;
+      const headers = {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      };
+      const fetchOpts = { method, headers };
+      if (method === "POST" || method === "PATCH" || method === "PUT") {
+        const body = { ...input };
+        delete body.id;
+        fetchOpts.body = JSON.stringify(body);
+      }
+      const res = await fetch(url, fetchOpts);
+      if (res.status === 401) {
+        throw new Error("Authentication expired. Run `crmy login` to re-authenticate.");
+      }
+      const responseBody = await res.text();
+      if (!res.ok) {
+        let detail = responseBody;
+        try {
+          detail = JSON.parse(responseBody).detail ?? responseBody;
+        } catch {
+        }
+        throw new Error(`API error (${res.status}): ${detail}`);
+      }
+      return responseBody;
+    },
+    async close() {
+    }
+  };
+}
+async function createDbClient(databaseUrl, apiKey) {
+  process.env.CRMY_IMPORTED = "1";
+  const { initPool, closePool, getAllTools } = await import("@crmy/server");
+  const db = await initPool(databaseUrl);
+  let actor = {
+    tenant_id: "",
+    actor_id: "cli-user",
+    actor_type: "user",
+    role: "owner"
+  };
+  if (apiKey) {
+    const crypto2 = await import("crypto");
+    const keyHash = crypto2.createHash("sha256").update(apiKey).digest("hex");
+    const result = await db.query(
+      `SELECT ak.tenant_id, ak.user_id, u.role
+       FROM api_keys ak LEFT JOIN users u ON ak.user_id = u.id
+       WHERE ak.key_hash = $1`,
+      [keyHash]
+    );
+    if (result.rows.length > 0) {
+      actor.tenant_id = result.rows[0].tenant_id;
+      actor.actor_id = result.rows[0].user_id ?? "cli-user";
+      actor.role = result.rows[0].role ?? "owner";
+    }
+  }
+  if (!actor.tenant_id) {
+    const tenantResult = await db.query("SELECT id FROM tenants WHERE slug = 'default' LIMIT 1");
+    if (tenantResult.rows.length > 0) {
+      actor.tenant_id = tenantResult.rows[0].id;
+    }
+  }
+  const tools = getAllTools(db);
+  return {
+    async call(toolName, input) {
+      const tool = tools.find((t) => t.name === toolName);
+      if (!tool) throw new Error(`Unknown tool: ${toolName}`);
+      const result = await tool.handler(input, actor);
+      return JSON.stringify(result, null, 2);
+    },
+    async close() {
+      await closePool();
+    }
+  };
+}
+async function getClient() {
+  const config = loadConfigFile();
+  const databaseUrl = process.env.DATABASE_URL ?? config.database?.url;
+  if (databaseUrl) {
+    const apiKey2 = process.env.CRMY_API_KEY ?? config.apiKey;
+    return createDbClient(databaseUrl, apiKey2);
+  }
+  const auth = loadAuthState();
+  if (auth) {
+    return createHttpClient(auth.serverUrl, auth.token);
+  }
+  const serverUrl = process.env.CRMY_SERVER_URL ?? config.serverUrl;
+  const apiKey = process.env.CRMY_API_KEY ?? config.apiKey;
+  if (serverUrl && apiKey) {
+    return createHttpClient(serverUrl, apiKey);
+  }
+  console.error("Not connected. Run `crmy auth setup` and `crmy login`, or `crmy init` for local mode.");
+  process.exit(1);
+}
+
+// src/commands/contacts.ts
+function contactsCommand() {
+  const cmd = new Command4("contacts").description("Manage contacts");
+  cmd.command("list").option("-q, --query <query>", "Search query").option("--stage <stage>", "Filter by lifecycle stage").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("contact_search", {
+      query: opts.query,
+      lifecycle_stage: opts.stage,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.contacts?.length === 0) {
+      console.log("No contacts found.");
+      return;
+    }
+    console.table(data.contacts?.map((c) => ({
+      id: c.id.slice(0, 8),
+      name: `${c.first_name} ${c.last_name}`,
+      email: c.email ?? "",
+      stage: c.lifecycle_stage,
+      company: c.company_name ?? ""
+    })));
+    if (data.total > 20) console.log(`
+  Showing 20 of ${data.total} contacts`);
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("contact_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("create").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "first_name", message: "First name:" },
+      { type: "input", name: "last_name", message: "Last name:" },
+      { type: "input", name: "email", message: "Email:" },
+      { type: "input", name: "company_name", message: "Company:" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("contact_create", {
+      first_name: answers.first_name,
+      last_name: answers.last_name || void 0,
+      email: answers.email || void 0,
+      company_name: answers.company_name || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Created contact: ${data.contact.id}
+`);
+    await client.close();
+  });
+  cmd.command("delete <id>").description("Permanently delete a contact (admin/owner only)").action(async (id) => {
+    const { default: inquirer } = await import("inquirer");
+    const { confirm } = await inquirer.prompt([
+      { type: "confirm", name: "confirm", message: `Delete contact ${id}? This cannot be undone.`, default: false }
+    ]);
+    if (!confirm) {
+      console.log("  Cancelled.");
+      return;
+    }
+    const client = await getClient();
+    const result = await client.call("contact_delete", { id });
+    const data = JSON.parse(result);
+    if (data.deleted) console.log(`  Deleted.`);
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/accounts.ts
+import { Command as Command5 } from "commander";
+function accountsCommand() {
+  const cmd = new Command5("accounts").description("Manage accounts");
+  cmd.command("list").option("-q, --query <query>", "Search query").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("account_search", { query: opts.query, limit: 20 });
+    const data = JSON.parse(result);
+    if (data.accounts?.length === 0) {
+      console.log("No accounts found.");
+      return;
+    }
+    console.table(data.accounts?.map((a) => ({
+      id: a.id.slice(0, 8),
+      name: a.name,
+      industry: a.industry ?? "",
+      health: a.health_score ?? ""
+    })));
+    await client.close();
+  });
+  cmd.command("get <id>").description("Get account details including contacts and open opportunities").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("account_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("create").description("Create a new account").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "name", message: "Account name:" },
+      { type: "input", name: "domain", message: "Domain (optional):" },
+      { type: "input", name: "industry", message: "Industry (optional):" },
+      { type: "input", name: "website", message: "Website (optional):" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("account_create", {
+      name: answers.name,
+      domain: answers.domain || void 0,
+      industry: answers.industry || void 0,
+      website: answers.website || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Created account: ${data.account.id}
+`);
+    await client.close();
+  });
+  cmd.command("delete <id>").description("Permanently delete an account (admin/owner only)").action(async (id) => {
+    const { default: inquirer } = await import("inquirer");
+    const { confirm } = await inquirer.prompt([
+      { type: "confirm", name: "confirm", message: `Delete account ${id}? This cannot be undone.`, default: false }
+    ]);
+    if (!confirm) {
+      console.log("  Cancelled.");
+      return;
+    }
+    const client = await getClient();
+    const result = await client.call("account_delete", { id });
+    const data = JSON.parse(result);
+    if (data.deleted) console.log(`  Deleted.`);
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/opps.ts
+import { Command as Command6 } from "commander";
+function oppsCommand() {
+  const cmd = new Command6("opps").description("Manage opportunities");
+  cmd.command("list").option("--stage <stage>", "Filter by stage").option("-q, --query <query>", "Search query").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("opportunity_search", { query: opts.query, stage: opts.stage, limit: 20 });
+    const data = JSON.parse(result);
+    if (data.opportunities?.length === 0) {
+      console.log("No opportunities found.");
+      return;
+    }
+    console.table(data.opportunities?.map((o) => ({
+      id: o.id.slice(0, 8),
+      name: o.name,
+      stage: o.stage,
+      amount: o.amount ?? 0,
+      close_date: o.close_date ?? ""
+    })));
+    if (data.total > 20) console.log(`
+  Showing 20 of ${data.total} opportunities`);
+    await client.close();
+  });
+  cmd.command("get <id>").description("Get opportunity details").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("opportunity_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("create").description("Create a new opportunity").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "name", message: "Opportunity name:" },
+      { type: "input", name: "account_id", message: "Account ID (optional):" },
+      { type: "input", name: "amount", message: "Amount (optional):" },
+      {
+        type: "list",
+        name: "stage",
+        message: "Stage:",
+        choices: ["prospecting", "qualification", "proposal", "negotiation", "closed_won", "closed_lost"],
+        default: "prospecting"
+      },
+      { type: "input", name: "close_date", message: "Close date YYYY-MM-DD (optional):" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("opportunity_create", {
+      name: answers.name,
+      account_id: answers.account_id || void 0,
+      amount: answers.amount ? parseFloat(answers.amount) : void 0,
+      stage: answers.stage,
+      close_date: answers.close_date || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Created opportunity: ${data.opportunity.id}
+`);
+    await client.close();
+  });
+  cmd.command("advance <id> <stage>").description("Advance opportunity to a new stage").option("--note <note>", "Optional note").option("--lost-reason <reason>", "Required when stage is closed_lost").action(async (id, stage, opts) => {
+    const client = await getClient();
+    const result = await client.call("opportunity_advance_stage", {
+      id,
+      stage,
+      note: opts.note,
+      lost_reason: opts.lostReason
+    });
+    const data = JSON.parse(result);
+    console.log(`  Stage updated to: ${data.opportunity.stage}`);
+    await client.close();
+  });
+  cmd.command("delete <id>").description("Permanently delete an opportunity (admin/owner only)").action(async (id) => {
+    const { default: inquirer } = await import("inquirer");
+    const { confirm } = await inquirer.prompt([
+      { type: "confirm", name: "confirm", message: `Delete opportunity ${id}? This cannot be undone.`, default: false }
+    ]);
+    if (!confirm) {
+      console.log("  Cancelled.");
+      return;
+    }
+    const client = await getClient();
+    const result = await client.call("opportunity_delete", { id });
+    const data = JSON.parse(result);
+    if (data.deleted) console.log(`  Deleted.`);
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/pipeline.ts
+import { Command as Command7 } from "commander";
+function pipelineCommand() {
+  return new Command7("pipeline").description("Show pipeline summary by stage").action(async () => {
+    const client = await getClient();
+    const result = await client.call("pipeline_summary", { group_by: "stage" });
+    const data = JSON.parse(result);
+    console.log(`
+  Pipeline: $${(data.total_value / 100).toLocaleString()} across ${data.count} opportunities
+`);
+    if (data.by_stage?.length > 0) {
+      console.table(data.by_stage.map((s) => ({
+        stage: s.stage,
+        count: s.count,
+        value: `$${(s.value / 100).toLocaleString()}`
+      })));
+    }
+    await client.close();
+  });
+}
+
+// src/commands/search.ts
+import { Command as Command8 } from "commander";
+function searchCommand() {
+  return new Command8("search").description("Cross-entity search").argument("<query>", "Search query").action(async (query) => {
+    const client = await getClient();
+    const result = await client.call("crm_search", { query, limit: 10 });
+    const data = JSON.parse(result);
+    if (data.contacts?.length > 0) {
+      console.log("\n  Contacts:");
+      console.table(data.contacts.map((c) => ({
+        id: c.id.slice(0, 8),
+        name: `${c.first_name} ${c.last_name}`,
+        email: c.email ?? ""
+      })));
+    }
+    if (data.accounts?.length > 0) {
+      console.log("\n  Accounts:");
+      console.table(data.accounts.map((a) => ({
+        id: a.id.slice(0, 8),
+        name: a.name
+      })));
+    }
+    if (data.opportunities?.length > 0) {
+      console.log("\n  Opportunities:");
+      console.table(data.opportunities.map((o) => ({
+        id: o.id.slice(0, 8),
+        name: o.name,
+        stage: o.stage
+      })));
+    }
+    const total = (data.contacts?.length ?? 0) + (data.accounts?.length ?? 0) + (data.opportunities?.length ?? 0);
+    if (total === 0) console.log("  No results found.");
+    await client.close();
+  });
+}
+
+// src/commands/hitl.ts
+import { Command as Command9 } from "commander";
+function hitlCommand() {
+  const cmd = new Command9("hitl").description("Manage HITL approval requests");
+  cmd.command("list").action(async () => {
+    const client = await getClient();
+    const result = await client.call("hitl_list_pending", { limit: 20 });
+    const data = JSON.parse(result);
+    if (data.requests?.length === 0) {
+      console.log("No pending HITL requests.");
+      return;
+    }
+    console.table(data.requests.map((r) => ({
+      id: r.id.slice(0, 8),
+      type: r.action_type,
+      summary: r.action_summary,
+      created: r.created_at
+    })));
+    await client.close();
+  });
+  cmd.command("approve <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("hitl_resolve", { request_id: id, decision: "approved" });
+    console.log("Approved:", JSON.parse(result).request.id);
+    await client.close();
+  });
+  cmd.command("reject <id>").option("--note <note>", "Rejection note").action(async (id, opts) => {
+    const client = await getClient();
+    const result = await client.call("hitl_resolve", {
+      request_id: id,
+      decision: "rejected",
+      note: opts.note
+    });
+    console.log("Rejected:", JSON.parse(result).request.id);
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/events.ts
+import { Command as Command10 } from "commander";
+function eventsCommand() {
+  return new Command10("events").description("View audit log").option("--object <id>", "Filter by object ID").option("--type <type>", "Filter by event type").action(async (opts) => {
+    const config = loadConfigFile();
+    const databaseUrl = process.env.DATABASE_URL ?? config.database?.url;
+    if (!databaseUrl) {
+      console.error("No database URL configured.");
+      process.exit(1);
+    }
+    process.env.CRMY_IMPORTED = "1";
+    const { initPool, closePool } = await import("@crmy/server");
+    const { searchEvents } = await import("@crmy/server/dist/db/repos/events.js");
+    const db = await initPool(databaseUrl);
+    const tenantResult = await db.query("SELECT id FROM tenants WHERE slug = 'default' LIMIT 1");
+    if (tenantResult.rows.length === 0) {
+      console.log("No tenant found. Run crmy init first.");
+      await closePool();
+      return;
+    }
+    const result = await searchEvents(db, tenantResult.rows[0].id, {
+      object_id: opts.object,
+      event_type: opts.type,
+      limit: 50
+    });
+    if (result.data.length === 0) {
+      console.log("No events found.");
+    } else {
+      console.table(result.data.map((e) => ({
+        id: e.id,
+        type: e.event_type,
+        actor: e.actor_type,
+        object: e.object_type,
+        created: e.created_at
+      })));
+    }
+    await closePool();
+  });
+}
+
+// src/commands/config.ts
+import { Command as Command11 } from "commander";
+function configCommand() {
+  return new Command11("config").description("Show configuration").command("show").action(() => {
+    const config = loadConfigFile();
+    if (Object.keys(config).length === 0) {
+      console.log("No .crmy.json found. Run `crmy init` to create one.");
+      return;
+    }
+    const display = {
+      ...config,
+      apiKey: config.apiKey ? config.apiKey.slice(0, 10) + "..." : void 0,
+      jwtSecret: config.jwtSecret ? "***" : void 0
+    };
+    console.log(JSON.stringify(display, null, 2));
+  });
+}
+
+// src/commands/migrate.ts
+import { Command as Command12 } from "commander";
+function migrateCommand() {
+  const cmd = new Command12("migrate").description("Database migrations");
+  cmd.command("run").action(async () => {
+    const config = loadConfigFile();
+    const databaseUrl = process.env.DATABASE_URL ?? config.database?.url;
+    if (!databaseUrl) {
+      console.error("No database URL configured.");
+      process.exit(1);
+    }
+    process.env.CRMY_IMPORTED = "1";
+    const { initPool, closePool, runMigrations } = await import("@crmy/server");
+    const db = await initPool(databaseUrl);
+    const ran = await runMigrations(db);
+    if (ran.length === 0) {
+      console.log("No pending migrations.");
+    } else {
+      console.log(`Ran ${ran.length} migration(s): ${ran.join(", ")}`);
+    }
+    await closePool();
+  });
+  cmd.command("status").action(async () => {
+    const config = loadConfigFile();
+    const databaseUrl = process.env.DATABASE_URL ?? config.database?.url;
+    if (!databaseUrl) {
+      console.error("No database URL configured.");
+      process.exit(1);
+    }
+    process.env.CRMY_IMPORTED = "1";
+    const { initPool, closePool } = await import("@crmy/server");
+    const { getMigrationStatus } = await import("@crmy/server/dist/db/migrate.js");
+    const db = await initPool(databaseUrl);
+    const status = await getMigrationStatus(db);
+    console.log("Applied:", status.applied.length ? status.applied.join(", ") : "(none)");
+    console.log("Pending:", status.pending.length ? status.pending.join(", ") : "(none)");
+    await closePool();
+  });
+  return cmd;
+}
+
+// src/commands/use-cases.ts
+import { Command as Command13 } from "commander";
+function useCasesCommand() {
+  const cmd = new Command13("use-cases").description("Manage use cases");
+  cmd.command("list").option("--account <id>", "Filter by account ID").option("--stage <stage>", "Filter by stage").option("-q, --query <query>", "Search query").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("use_case_search", {
+      account_id: opts.account,
+      stage: opts.stage,
+      query: opts.query,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.use_cases?.length === 0) {
+      console.log("No use cases found.");
+      return;
+    }
+    console.table(data.use_cases?.map((uc) => ({
+      id: uc.id.slice(0, 8),
+      name: uc.name,
+      stage: uc.stage,
+      arr: uc.attributed_arr ?? "",
+      health: uc.health_score ?? ""
+    })));
+    if (data.total > 20) console.log(`
+  Showing 20 of ${data.total} use cases`);
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("use_case_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("create").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "account_id", message: "Account ID:" },
+      { type: "input", name: "name", message: "Use case name:" },
+      { type: "input", name: "description", message: "Description:" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("use_case_create", {
+      account_id: answers.account_id,
+      name: answers.name,
+      description: answers.description || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Created use case: ${data.use_case.id}
+`);
+    await client.close();
+  });
+  cmd.command("summary").option("--account <id>", "Filter by account ID").option("--group-by <field>", "Group by: stage, product_line, owner", "stage").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("use_case_summary", {
+      account_id: opts.account,
+      group_by: opts.groupBy
+    });
+    const data = JSON.parse(result);
+    console.table(data.summary);
+    await client.close();
+  });
+  cmd.command("delete <id>").description("Delete a use case (admin/owner only)").action(async (id) => {
+    const { default: inquirer } = await import("inquirer");
+    const { confirm } = await inquirer.prompt([
+      { type: "confirm", name: "confirm", message: `Delete use case ${id}? This cannot be undone.`, default: false }
+    ]);
+    if (!confirm) {
+      console.log("  Cancelled.");
+      return;
+    }
+    const client = await getClient();
+    const result = await client.call("use_case_delete", { id });
+    const data = JSON.parse(result);
+    if (data.deleted) console.log(`  Deleted.`);
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/webhooks.ts
+import { Command as Command14 } from "commander";
+function webhooksCommand() {
+  const cmd = new Command14("webhooks").description("Manage webhook endpoints");
+  cmd.command("list").option("--active", "Show only active webhooks").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("webhook_list", {
+      active: opts.active ?? void 0,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.webhooks?.length === 0) {
+      console.log("No webhooks found.");
+      return;
+    }
+    console.table(data.webhooks?.map((w) => ({
+      id: w.id.slice(0, 8),
+      url: w.url,
+      events: w.event_types?.join(", "),
+      active: w.is_active
+    })));
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("webhook_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("create").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "url", message: "Webhook URL:" },
+      { type: "input", name: "events", message: "Events (comma-separated):" },
+      { type: "input", name: "description", message: "Description:" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("webhook_create", {
+      url: answers.url,
+      events: answers.events.split(",").map((e) => e.trim()),
+      description: answers.description || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Created webhook: ${data.webhook.id}
+`);
+    console.log(`  Secret: ${data.webhook.secret}
+`);
+    await client.close();
+  });
+  cmd.command("delete <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("webhook_delete", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("deliveries").option("--endpoint <id>", "Filter by endpoint ID").option("--status <status>", "Filter by status (pending, success, failed)").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("webhook_list_deliveries", {
+      endpoint_id: opts.endpoint,
+      status: opts.status,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.deliveries?.length === 0) {
+      console.log("No deliveries found.");
+      return;
+    }
+    console.table(data.deliveries?.map((d) => ({
+      id: d.id.slice(0, 8),
+      event_type: d.event_type,
+      status: d.status,
+      attempts: d.attempt_count,
+      created: d.created_at
+    })));
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/emails.ts
+import { Command as Command15 } from "commander";
+function emailsCommand() {
+  const cmd = new Command15("emails").description("Manage outbound emails");
+  cmd.command("list").option("--contact <id>", "Filter by contact ID").option("--status <status>", "Filter by status").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("email_search", {
+      contact_id: opts.contact,
+      status: opts.status,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.emails?.length === 0) {
+      console.log("No emails found.");
+      return;
+    }
+    console.table(data.emails?.map((e) => ({
+      id: e.id.slice(0, 8),
+      to: e.to_email,
+      subject: e.subject,
+      status: e.status,
+      created: e.created_at
+    })));
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("email_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("create").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "to_address", message: "To (email):" },
+      { type: "input", name: "subject", message: "Subject:" },
+      { type: "input", name: "body_text", message: "Body:" },
+      { type: "input", name: "contact_id", message: "Contact ID (optional):" },
+      { type: "confirm", name: "require_approval", message: "Require HITL approval?", default: true }
+    ]);
+    const client = await getClient();
+    const result = await client.call("email_create", {
+      to_address: answers.to_address,
+      subject: answers.subject,
+      body_text: answers.body_text,
+      contact_id: answers.contact_id || void 0,
+      require_approval: answers.require_approval
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Created email: ${data.email.id}  status: ${data.email.status}
+`);
+    if (data.hitl_request_id) {
+      console.log(`  HITL approval required: ${data.hitl_request_id}
+`);
+    }
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/custom-fields.ts
+import { Command as Command16 } from "commander";
+function customFieldsCommand() {
+  const cmd = new Command16("custom-fields").description("Manage custom field definitions");
+  cmd.command("list <object_type>").description("List custom fields for an object type (contact, account, opportunity, activity, use_case)").action(async (objectType) => {
+    const client = await getClient();
+    const result = await client.call("custom_field_list", { object_type: objectType });
+    const data = JSON.parse(result);
+    if (data.fields?.length === 0) {
+      console.log(`No custom fields defined for ${objectType}.`);
+      return;
+    }
+    console.table(data.fields?.map((f) => ({
+      id: f.id.slice(0, 8),
+      key: f.field_key,
+      label: f.label,
+      type: f.field_type,
+      required: f.is_required
+    })));
+    await client.close();
+  });
+  cmd.command("create").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      {
+        type: "list",
+        name: "object_type",
+        message: "Object type:",
+        choices: ["contact", "account", "opportunity", "activity", "use_case"]
+      },
+      { type: "input", name: "field_name", message: "Field key (snake_case):" },
+      { type: "input", name: "label", message: "Display label:" },
+      {
+        type: "list",
+        name: "field_type",
+        message: "Field type:",
+        choices: ["text", "number", "boolean", "date", "select", "multi_select"]
+      },
+      { type: "confirm", name: "required", message: "Required?", default: false }
+    ]);
+    const client = await getClient();
+    const result = await client.call("custom_field_create", answers);
+    const data = JSON.parse(result);
+    console.log(`
+  Created custom field: ${data.field.id}
+`);
+    await client.close();
+  });
+  cmd.command("delete <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("custom_field_delete", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/notes.ts
+import { Command as Command17 } from "commander";
+function notesCommand() {
+  const cmd = new Command17("notes").description("Manage notes and comments on CRM objects");
+  cmd.command("list <object_type> <object_id>").description("List notes for an object (contact, account, opportunity, use_case)").option("--visibility <vis>", "Filter: internal or external").option("--pinned", "Show only pinned notes").action(async (objectType, objectId, opts) => {
+    const client = await getClient();
+    const result = await client.call("note_list", {
+      object_type: objectType,
+      object_id: objectId,
+      visibility: opts.visibility,
+      pinned: opts.pinned ?? void 0,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.notes?.length === 0) {
+      console.log("No notes found.");
+      return;
+    }
+    for (const n of data.notes ?? []) {
+      const pin = n.pinned ? " \u{1F4CC}" : "";
+      const vis = n.visibility === "external" ? " [external]" : "";
+      console.log(`  [${n.id.slice(0, 8)}]${pin}${vis} ${n.author_type}/${n.author_id ?? "anon"}`);
+      console.log(`    ${n.body.slice(0, 120)}`);
+      console.log(`    ${n.created_at}
+`);
+    }
+    if (data.total > 20) console.log(`  Showing 20 of ${data.total} notes`);
+    await client.close();
+  });
+  cmd.command("add <object_type> <object_id>").description("Add a note to an object").option("--parent <id>", "Reply to a note (thread)").option("--external", "Make note visible externally").option("--pin", "Pin this note").action(async (objectType, objectId, opts) => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "body", message: "Note:" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("note_create", {
+      object_type: objectType,
+      object_id: objectId,
+      body: answers.body,
+      parent_id: opts.parent,
+      visibility: opts.external ? "external" : "internal",
+      pinned: opts.pin ?? false
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Note created: ${data.note.id}
+`);
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("note_get", { id });
+    const data = JSON.parse(result);
+    console.log(`
+  ${data.note.body}
+`);
+    if (data.replies?.length > 0) {
+      console.log(`  ${data.replies.length} replies:`);
+      for (const r of data.replies) {
+        console.log(`    [${r.id.slice(0, 8)}] ${r.body.slice(0, 80)}`);
+      }
+    }
+    await client.close();
+  });
+  cmd.command("delete <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("note_delete", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/workflows.ts
+import { Command as Command18 } from "commander";
+function workflowsCommand() {
+  const cmd = new Command18("workflows").description("Manage automation workflows");
+  cmd.command("list").option("--trigger <event>", "Filter by trigger event").option("--active", "Show only active workflows").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("workflow_list", {
+      trigger_event: opts.trigger,
+      is_active: opts.active ?? void 0,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.workflows?.length === 0) {
+      console.log("No workflows found.");
+      return;
+    }
+    console.table(data.workflows?.map((w) => ({
+      id: w.id.slice(0, 8),
+      name: w.name,
+      trigger: w.trigger_event,
+      active: w.is_active,
+      runs: w.run_count
+    })));
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("workflow_get", { id });
+    const data = JSON.parse(result);
+    console.log("\nWorkflow:", data.workflow.name);
+    console.log("Trigger:", data.workflow.trigger_event);
+    console.log("Active:", data.workflow.is_active);
+    console.log("Actions:", JSON.stringify(data.workflow.actions, null, 2));
+    if (data.recent_runs?.length > 0) {
+      console.log("\nRecent runs:");
+      console.table(data.recent_runs.map((r) => ({
+        id: r.id.slice(0, 8),
+        status: r.status,
+        actions: `${r.actions_run}/${r.actions_total}`,
+        started: r.started_at
+      })));
+    }
+    await client.close();
+  });
+  cmd.command("create").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "name", message: "Workflow name:" },
+      { type: "input", name: "trigger_event", message: "Trigger event (e.g. contact.created):" },
+      { type: "input", name: "description", message: "Description:" }
+    ]);
+    const actionAnswers = await inquirer.prompt([
+      {
+        type: "list",
+        name: "type",
+        message: "Action type:",
+        choices: ["send_notification", "create_activity", "create_note", "add_tag", "webhook"]
+      },
+      { type: "input", name: "message", message: "Action message/body:" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("workflow_create", {
+      name: answers.name,
+      description: answers.description || void 0,
+      trigger_event: answers.trigger_event,
+      actions: [{ type: actionAnswers.type, config: { message: actionAnswers.message } }]
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Created workflow: ${data.workflow.id}
+`);
+    await client.close();
+  });
+  cmd.command("delete <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("workflow_delete", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("runs <workflow_id>").option("--status <status>", "Filter: running, completed, failed").action(async (workflowId, opts) => {
+    const client = await getClient();
+    const result = await client.call("workflow_run_list", {
+      workflow_id: workflowId,
+      status: opts.status,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.runs?.length === 0) {
+      console.log("No runs found.");
+      return;
+    }
+    console.table(data.runs?.map((r) => ({
+      id: r.id.slice(0, 8),
+      status: r.status,
+      actions: `${r.actions_run}/${r.actions_total}`,
+      error: r.error ?? "",
+      started: r.started_at
+    })));
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/actors.ts
+import { Command as Command19 } from "commander";
+function actorsCommand() {
+  const cmd = new Command19("actors").description("Manage actors (humans & agents)");
+  cmd.command("list").option("--type <type>", "Filter by actor_type (human or agent)").option("-q, --query <query>", "Search query").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("actor_list", {
+      actor_type: opts.type,
+      query: opts.query,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.actors?.length === 0) {
+      console.log("No actors found.");
+      return;
+    }
+    console.table(data.actors?.map((a) => ({
+      id: a.id.slice(0, 8),
+      type: a.actor_type,
+      name: a.display_name,
+      email: a.email ?? "",
+      agent_id: a.agent_identifier ?? "",
+      active: a.is_active ? "\u2713" : "\u2717"
+    })));
+    if (data.total > 20) console.log(`
+  Showing 20 of ${data.total} actors`);
+    await client.close();
+  });
+  cmd.command("register").description("Register a new actor").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "list", name: "actor_type", message: "Actor type:", choices: ["human", "agent"] },
+      { type: "input", name: "display_name", message: "Display name:" },
+      { type: "input", name: "email", message: "Email (for humans):" },
+      { type: "input", name: "agent_identifier", message: "Agent identifier (for agents):" },
+      { type: "input", name: "agent_model", message: "Agent model (e.g. claude-sonnet-4-20250514):" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("actor_register", {
+      actor_type: answers.actor_type,
+      display_name: answers.display_name,
+      email: answers.email || void 0,
+      agent_identifier: answers.agent_identifier || void 0,
+      agent_model: answers.agent_model || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Registered actor: ${data.actor.id}
+`);
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("actor_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("whoami").description("Show current actor identity").action(async () => {
+    const client = await getClient();
+    const result = await client.call("actor_whoami", {});
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/assignments.ts
+import { Command as Command20 } from "commander";
+function assignmentsCommand() {
+  const cmd = new Command20("assignments").description("Manage assignments (coordination & handoffs)");
+  cmd.command("list").option("--mine", "Show assignments assigned to me").option("--delegated", "Show assignments I created").option("--status <status>", "Filter by status").option("--priority <priority>", "Filter by priority").action(async (opts) => {
+    const client = await getClient();
+    const input = { limit: 20 };
+    if (opts.mine) {
+      const whoami = JSON.parse(await client.call("actor_whoami", {}));
+      input.assigned_to = whoami.actor_id;
+    }
+    if (opts.delegated) {
+      const whoami = JSON.parse(await client.call("actor_whoami", {}));
+      input.assigned_by = whoami.actor_id;
+    }
+    if (opts.status) input.status = opts.status;
+    if (opts.priority) input.priority = opts.priority;
+    const result = await client.call("assignment_list", input);
+    const data = JSON.parse(result);
+    if (data.assignments?.length === 0) {
+      console.log("No assignments found.");
+      return;
+    }
+    console.table(data.assignments?.map((a) => ({
+      id: a.id.slice(0, 8),
+      title: a.title.slice(0, 40),
+      type: a.assignment_type,
+      status: a.status,
+      priority: a.priority,
+      subject: `${a.subject_type}:${a.subject_id.slice(0, 8)}`
+    })));
+    if (data.total > 20) console.log(`
+  Showing 20 of ${data.total} assignments`);
+    await client.close();
+  });
+  cmd.command("create").description("Create a new assignment").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "input", name: "title", message: "Title:" },
+      { type: "input", name: "description", message: "Description:" },
+      { type: "list", name: "assignment_type", message: "Type:", choices: ["follow_up", "review", "approve", "send", "call", "meet", "research", "draft", "custom"] },
+      { type: "input", name: "assigned_to", message: "Assign to (actor UUID):" },
+      { type: "list", name: "subject_type", message: "Subject type:", choices: ["contact", "account", "opportunity", "use_case"] },
+      { type: "input", name: "subject_id", message: "Subject ID (UUID):" },
+      { type: "list", name: "priority", message: "Priority:", choices: ["low", "normal", "high", "urgent"], default: "normal" },
+      { type: "input", name: "context", message: "Context / handoff notes:" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("assignment_create", {
+      title: answers.title,
+      description: answers.description || void 0,
+      assignment_type: answers.assignment_type,
+      assigned_to: answers.assigned_to,
+      subject_type: answers.subject_type,
+      subject_id: answers.subject_id,
+      priority: answers.priority,
+      context: answers.context || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Created assignment: ${data.assignment.id}
+`);
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("assignment_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("accept <id>").description("Accept a pending assignment").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("assignment_accept", { id });
+    const data = JSON.parse(result);
+    console.log(`
+  Accepted assignment: ${data.assignment.id} (status: ${data.assignment.status})
+`);
+    await client.close();
+  });
+  cmd.command("complete <id>").option("--activity <activityId>", "Link the completing activity").description("Complete an assignment").action(async (id, opts) => {
+    const client = await getClient();
+    const result = await client.call("assignment_complete", {
+      id,
+      completed_by_activity_id: opts.activity || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Completed assignment: ${data.assignment.id}
+`);
+    await client.close();
+  });
+  cmd.command("decline <id>").option("-r, --reason <reason>", "Reason for declining").description("Decline an assignment").action(async (id, opts) => {
+    const client = await getClient();
+    const result = await client.call("assignment_decline", {
+      id,
+      reason: opts.reason || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Declined assignment: ${data.assignment.id}
+`);
+    await client.close();
+  });
+  cmd.command("start <id>").description("Start working on an accepted assignment").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("assignment_start", { id });
+    const data = JSON.parse(result);
+    console.log(`
+  Started assignment: ${data.assignment.id} (status: ${data.assignment.status})
+`);
+    await client.close();
+  });
+  cmd.command("block <id>").option("-r, --reason <reason>", "Reason for blocking").description("Mark an assignment as blocked").action(async (id, opts) => {
+    const client = await getClient();
+    const result = await client.call("assignment_block", {
+      id,
+      reason: opts.reason || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Blocked assignment: ${data.assignment.id}
+`);
+    await client.close();
+  });
+  cmd.command("cancel <id>").option("-r, --reason <reason>", "Reason for cancelling").description("Cancel an assignment").action(async (id, opts) => {
+    const client = await getClient();
+    const result = await client.call("assignment_cancel", {
+      id,
+      reason: opts.reason || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Cancelled assignment: ${data.assignment.id}
+`);
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/context.ts
+import { Command as Command21 } from "commander";
+function contextCommand() {
+  const cmd = new Command21("context").description("Manage context entries (knowledge & memory)");
+  cmd.command("list").option("--subject-type <type>", "Filter by subject type (contact, account, opportunity, use_case)").option("--subject-id <id>", "Filter by subject ID").option("--type <contextType>", "Filter by context type (note, research, objection, etc.)").option("--current-only", "Only show current entries (default behavior)").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("context_list", {
+      subject_type: opts.subjectType,
+      subject_id: opts.subjectId,
+      context_type: opts.type,
+      is_current: opts.currentOnly ? true : void 0,
+      limit: 20
+    });
+    const data = JSON.parse(result);
+    if (data.context_entries?.length === 0) {
+      console.log("No context entries found.");
+      return;
+    }
+    console.table(data.context_entries?.map((c) => ({
+      id: c.id.slice(0, 8),
+      type: c.context_type,
+      title: (c.title ?? "").slice(0, 40),
+      subject: `${c.subject_type}:${c.subject_id.slice(0, 8)}`,
+      confidence: c.confidence ?? "\u2014",
+      current: c.is_current ? "\u2713" : "\u2717"
+    })));
+    if (data.total > 20) console.log(`
+  Showing 20 of ${data.total} entries`);
+    await client.close();
+  });
+  cmd.command("add").description("Add context about a CRM object").action(async () => {
+    const { default: inquirer } = await import("inquirer");
+    const answers = await inquirer.prompt([
+      { type: "list", name: "subject_type", message: "Subject type:", choices: ["contact", "account", "opportunity", "use_case"] },
+      { type: "input", name: "subject_id", message: "Subject ID (UUID):" },
+      { type: "list", name: "context_type", message: "Context type:", choices: ["note", "transcript", "summary", "research", "preference", "objection", "competitive_intel", "relationship_map", "meeting_notes", "agent_reasoning"] },
+      { type: "input", name: "title", message: "Title (optional):" },
+      { type: "editor", name: "body", message: "Body:" },
+      { type: "input", name: "confidence", message: "Confidence (0.0\u20131.0, optional):" },
+      { type: "input", name: "source", message: "Source (e.g. manual, call_transcript, agent_research):" }
+    ]);
+    const client = await getClient();
+    const result = await client.call("context_add", {
+      subject_type: answers.subject_type,
+      subject_id: answers.subject_id,
+      context_type: answers.context_type,
+      title: answers.title || void 0,
+      body: answers.body,
+      confidence: answers.confidence ? parseFloat(answers.confidence) : void 0,
+      source: answers.source || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Added context: ${data.context_entry.id}
+`);
+    await client.close();
+  });
+  cmd.command("get <id>").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("context_get", { id });
+    console.log(JSON.parse(result));
+    await client.close();
+  });
+  cmd.command("supersede <id>").option("-b, --body <body>", "New body text").option("-t, --title <title>", "New title").description("Supersede an existing context entry with updated content").action(async (id, opts) => {
+    let body = opts.body;
+    if (!body) {
+      const { default: inquirer } = await import("inquirer");
+      const answers = await inquirer.prompt([
+        { type: "editor", name: "body", message: "Updated body:" }
+      ]);
+      body = answers.body;
+    }
+    const client = await getClient();
+    const result = await client.call("context_supersede", {
+      id,
+      body,
+      title: opts.title || void 0
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Superseded with new entry: ${data.context_entry.id}
+`);
+    await client.close();
+  });
+  cmd.command("search <query>").description("Full-text search across context entries").option("--subject <subject>", "Filter by subject (type:UUID)").option("--type <contextType>", "Filter by context type").option("--tag <tag>", "Filter by tag").option("--include-superseded", "Include non-current entries").option("--limit <n>", "Max results", "20").action(async (query, opts) => {
+    const input = {
+      query,
+      limit: parseInt(opts.limit, 10),
+      current_only: !opts.includeSuperseded
+    };
+    if (opts.subject) {
+      const [st, si] = opts.subject.split(":");
+      input.subject_type = st;
+      input.subject_id = si;
+    }
+    if (opts.type) input.context_type = opts.type;
+    if (opts.tag) input.tag = opts.tag;
+    const client = await getClient();
+    const result = await client.call("context_search", input);
+    const data = JSON.parse(result);
+    if (data.context_entries?.length === 0) {
+      console.log("No results found.");
+      return;
+    }
+    console.table(data.context_entries?.map((c) => ({
+      id: c.id.slice(0, 8),
+      type: c.context_type,
+      title: (c.title ?? "").slice(0, 40),
+      subject: `${c.subject_type}:${c.subject_id.slice(0, 8)}`,
+      confidence: c.confidence ?? "\u2014"
+    })));
+    await client.close();
+  });
+  cmd.command("review <id>").description("Mark a context entry as reviewed (still accurate)").action(async (id) => {
+    const client = await getClient();
+    const result = await client.call("context_review", { id });
+    const data = JSON.parse(result);
+    console.log(`
+  Reviewed context entry: ${data.context_entry.id} (reviewed_at: ${data.context_entry.reviewed_at})
+`);
+    await client.close();
+  });
+  cmd.command("stale").description("List stale context entries that need review").option("--subject <subject>", "Filter by subject (type:UUID)").option("--limit <n>", "Max results", "20").action(async (opts) => {
+    const input = { limit: parseInt(opts.limit, 10) };
+    if (opts.subject) {
+      const [st, si] = opts.subject.split(":");
+      input.subject_type = st;
+      input.subject_id = si;
+    }
+    const client = await getClient();
+    const result = await client.call("context_stale", input);
+    const data = JSON.parse(result);
+    if (data.stale_entries?.length === 0) {
+      console.log("No stale entries found.");
+      return;
+    }
+    console.table(data.stale_entries?.map((c) => ({
+      id: c.id.slice(0, 8),
+      type: c.context_type,
+      title: (c.title ?? "").slice(0, 40),
+      expired: c.valid_until,
+      subject: `${c.subject_type}:${c.subject_id.slice(0, 8)}`
+    })));
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/activity-types.ts
+import { Command as Command22 } from "commander";
+function activityTypesCommand() {
+  const cmd = new Command22("activity-types").description("Manage activity type registry");
+  cmd.command("list").option("--category <cat>", "Filter by category (outreach, meeting, proposal, contract, internal, lifecycle, handoff)").action(async (opts) => {
+    const client = await getClient();
+    const result = await client.call("activity_type_list", { category: opts.category });
+    const data = JSON.parse(result);
+    if (data.activity_types?.length === 0) {
+      console.log("No activity types found.");
+      return;
+    }
+    console.table(data.activity_types?.map((t) => ({
+      type_name: t.type_name,
+      label: t.label,
+      category: t.category,
+      default: t.is_default ? "\u2713" : ""
+    })));
+    await client.close();
+  });
+  cmd.command("add <type_name>").requiredOption("--label <label>", "Display label").requiredOption("--category <category>", "Category").option("--description <desc>", "Description").action(async (typeName, opts) => {
+    const client = await getClient();
+    const result = await client.call("activity_type_add", {
+      type_name: typeName,
+      label: opts.label,
+      category: opts.category,
+      description: opts.description
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Added activity type: ${data.activity_type.type_name}
+`);
+    await client.close();
+  });
+  cmd.command("remove <type_name>").description("Remove a custom activity type (cannot remove defaults)").action(async (typeName) => {
+    const client = await getClient();
+    try {
+      await client.call("activity_type_remove", { type_name: typeName });
+      console.log(`
+  Removed activity type: ${typeName}
+`);
+    } catch (err) {
+      console.error(`
+  Error: ${err instanceof Error ? err.message : err}
+`);
+    }
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/context-types.ts
+import { Command as Command23 } from "commander";
+function contextTypesCommand() {
+  const cmd = new Command23("context-types").description("Manage context type registry");
+  cmd.command("list").action(async () => {
+    const client = await getClient();
+    const result = await client.call("context_type_list", {});
+    const data = JSON.parse(result);
+    if (data.context_types?.length === 0) {
+      console.log("No context types found.");
+      return;
+    }
+    console.table(data.context_types?.map((t) => ({
+      type_name: t.type_name,
+      label: t.label,
+      description: (t.description ?? "").slice(0, 60),
+      default: t.is_default ? "\u2713" : ""
+    })));
+    await client.close();
+  });
+  cmd.command("add <type_name>").requiredOption("--label <label>", "Display label").option("--description <desc>", "Description").action(async (typeName, opts) => {
+    const client = await getClient();
+    const result = await client.call("context_type_add", {
+      type_name: typeName,
+      label: opts.label,
+      description: opts.description
+    });
+    const data = JSON.parse(result);
+    console.log(`
+  Added context type: ${data.context_type.type_name}
+`);
+    await client.close();
+  });
+  cmd.command("remove <type_name>").description("Remove a custom context type (cannot remove defaults)").action(async (typeName) => {
+    const client = await getClient();
+    try {
+      await client.call("context_type_remove", { type_name: typeName });
+      console.log(`
+  Removed context type: ${typeName}
+`);
+    } catch (err) {
+      console.error(`
+  Error: ${err instanceof Error ? err.message : err}
+`);
+    }
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/briefing.ts
+import { Command as Command24 } from "commander";
+function briefingCommand() {
+  const cmd = new Command24("briefing").description("Get a unified briefing for any CRM object \u2014 everything you need before taking action").argument("<subject>", "Subject as type:UUID (e.g. contact:550e8400-...)").option("--format <fmt>", "Output format (json or text)", "text").option("--since <duration>", "Filter activities by duration (e.g. 7d, 24h)").option("--context-types <types>", "Comma-separated context types to include").option("--include-stale", "Include superseded context entries").action(async (subject, opts) => {
+    const [subjectType, subjectId] = subject.split(":");
+    if (!subjectType || !subjectId) {
+      console.error("Subject must be in format type:UUID (e.g. contact:550e8400-...)");
+      process.exit(1);
+    }
+    const client = await getClient();
+    const result = await client.call("briefing_get", {
+      subject_type: subjectType,
+      subject_id: subjectId,
+      format: opts.format,
+      since: opts.since,
+      context_types: opts.contextTypes ? opts.contextTypes.split(",") : void 0,
+      include_stale: opts.includeStale ?? false
+    });
+    const data = JSON.parse(result);
+    if (opts.format === "text" && data.briefing_text) {
+      console.log(data.briefing_text);
+    } else {
+      console.log(JSON.stringify(data, null, 2));
+    }
+    await client.close();
+  });
+  return cmd;
+}
+
+// src/commands/auth.ts
+import { Command as Command25 } from "commander";
+function authCommand() {
+  const cmd = new Command25("auth").description("Authenticate against a CRMy server");
+  cmd.command("setup").description("Configure the CRMy server URL").argument("[url]", "Server URL (e.g. http://localhost:3000)").action(async (urlArg) => {
+    let serverUrl = urlArg;
+    if (!serverUrl) {
+      const { default: inquirer } = await import("inquirer");
+      const answers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "serverUrl",
+          message: "CRMy server URL:",
+          default: "http://localhost:3000"
+        }
+      ]);
+      serverUrl = answers.serverUrl;
+    }
+    try {
+      const res = await fetch(`${serverUrl.replace(/\/$/, "")}/health`);
+      if (!res.ok) {
+        console.error(`Server at ${serverUrl} returned ${res.status}`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      console.log(`
+  Connected to CRMy ${data.version} at ${serverUrl}
+`);
+      console.log("  Run `crmy login` to authenticate.\n");
+      const existing = loadAuthState();
+      if (existing) {
+        saveAuthState({ ...existing, serverUrl });
+      } else {
+        saveAuthState({
+          serverUrl,
+          token: "",
+          user: { id: "", email: "", name: "", role: "", tenant_id: "" }
+        });
+      }
+    } catch (err) {
+      console.error(`Could not connect to ${serverUrl}: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("login").description("Sign in with email and password").option("-e, --email <email>", "Email address").option("-p, --password <password>", "Password").action(async (opts) => {
+    const serverUrl = resolveServerUrl();
+    if (!serverUrl) {
+      console.error("No server configured. Run `crmy auth setup` first.");
+      process.exit(1);
+    }
+    let email = opts.email;
+    let password = opts.password;
+    if (!email || !password) {
+      const { default: inquirer } = await import("inquirer");
+      const answers = await inquirer.prompt([
+        ...email ? [] : [{ type: "input", name: "email", message: "Email:" }],
+        ...password ? [] : [{ type: "password", name: "password", message: "Password:", mask: "*" }]
+      ]);
+      email = email ?? answers.email;
+      password = password ?? answers.password;
+    }
+    try {
+      const res = await fetch(`${serverUrl.replace(/\/$/, "")}/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password })
+      });
+      if (!res.ok) {
+        const body = await res.json().catch(() => ({ detail: res.statusText }));
+        console.error(`Login failed: ${body.detail ?? res.statusText}`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      const payloadB64 = data.token.split(".")[1];
+      const payload = JSON.parse(Buffer.from(payloadB64, "base64url").toString());
+      const expiresAt = payload.exp ? new Date(payload.exp * 1e3).toISOString() : void 0;
+      saveAuthState({
+        serverUrl,
+        token: data.token,
+        user: data.user,
+        expiresAt
+      });
+      console.log(`
+  Logged in as ${data.user.name} (${data.user.email})`);
+      console.log(`  Role: ${data.user.role}`);
+      if (expiresAt) {
+        console.log(`  Token expires: ${new Date(expiresAt).toLocaleString()}`);
+      }
+      console.log();
+    } catch (err) {
+      console.error(`Login failed: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("status").description("Show current authentication status").action(() => {
+    const auth = loadAuthState();
+    if (!auth || !auth.token) {
+      console.log("\n  Not authenticated. Run `crmy login` to sign in.\n");
+      return;
+    }
+    console.log(`
+  Server:  ${auth.serverUrl}`);
+    console.log(`  User:    ${auth.user.name} (${auth.user.email})`);
+    console.log(`  Role:    ${auth.user.role}`);
+    if (auth.expiresAt) {
+      const expires = new Date(auth.expiresAt);
+      const remaining = expires.getTime() - Date.now();
+      if (remaining <= 0) {
+        console.log("  Token:   Expired \u2014 run `crmy login` to re-authenticate");
+      } else {
+        const mins = Math.floor(remaining / 6e4);
+        console.log(`  Token:   Valid (${mins}m remaining)`);
+      }
+    }
+    console.log();
+  });
+  cmd.command("logout").description("Clear stored credentials").action(() => {
+    clearAuthState();
+    console.log("\n  Logged out. Credentials cleared.\n");
+  });
+  return cmd;
+}
+
+// src/commands/help.ts
+import { Command as Command26 } from "commander";
+var HELP_TEXT = `
+  CRMy \u2014 The agent-first open source CRM
+
+  Usage: crmy <command> [options]
+
+  Setup & Auth
+    init                Initialize crmy: configure database, run migrations, create user
+    login               Sign in to a CRMy server (shortcut for crmy auth login)
+    auth                Manage authentication (login, logout, whoami)
+    config              View and update local configuration
+    migrate             Run database migrations
+
+  Server
+    server              Start the CRMy server
+    mcp                 Start the MCP stdio server for Claude Code
+
+  CRM Data
+    contacts            Manage contacts (list, get, create, update, delete)
+    accounts            Manage accounts (list, get, create, update, delete)
+    opps                Manage opportunities (list, get, create, update, delete)
+    pipeline            View and manage the sales pipeline
+    notes               Manage notes on CRM objects
+    custom-fields       Manage custom field definitions
+    search              Search across contacts, accounts, and opportunities
+
+  Automation
+    workflows           Manage automation workflows
+    events              View the event log
+    webhooks            Manage webhook subscriptions
+    emails              Send and manage emails
+    hitl                Human-in-the-loop approval queue
+
+  Resources
+    use-cases           Browse example use cases and templates
+
+  Options
+    -V, --version       Output the version number
+    -h, --help          Display help for a command
+
+  Examples
+    $ crmy init                     Set up a new CRMy instance
+    $ crmy server                   Start the server on :3000
+    $ crmy contacts list            List all contacts
+    $ crmy opps create              Create a new opportunity
+    $ crmy mcp                      Start MCP server for Claude Code
+
+  Run crmy <command> --help for detailed usage of any command.
+`;
+function helpCommand() {
+  return new Command26("help").description("Show detailed help and list all available commands").argument("[command]", "Show help for a specific command").allowExcessArguments(true).action(async (commandName, _opts, cmd) => {
+    if (commandName) {
+      const root = cmd.parent;
+      if (root) {
+        const sub = root.commands.find(
+          (c) => c.name() === commandName
+        );
+        if (sub) {
+          sub.outputHelp();
+          return;
+        }
+      }
+      console.error(`  Unknown command: ${commandName}
+`);
+      console.error(`  Run crmy help to see all available commands.`);
+      process.exitCode = 1;
+      return;
+    }
+    console.log(HELP_TEXT);
+  });
+}
+
+// src/index.ts
+var program = new Command27();
+program.name("crmy").description("CRMy \u2014 The agent-first open source CRM").version("0.5.0");
+program.addCommand(authCommand());
+program.addCommand(initCommand());
+program.addCommand(serverCommand());
+program.addCommand(mcpCommand());
+program.addCommand(contactsCommand());
+program.addCommand(accountsCommand());
+program.addCommand(oppsCommand());
+program.addCommand(pipelineCommand());
+program.addCommand(searchCommand());
+program.addCommand(hitlCommand());
+program.addCommand(eventsCommand());
+program.addCommand(configCommand());
+program.addCommand(migrateCommand());
+program.addCommand(useCasesCommand());
+program.addCommand(webhooksCommand());
+program.addCommand(emailsCommand());
+program.addCommand(customFieldsCommand());
+program.addCommand(notesCommand());
+program.addCommand(workflowsCommand());
+program.addCommand(actorsCommand());
+program.addCommand(assignmentsCommand());
+program.addCommand(contextCommand());
+program.addCommand(activityTypesCommand());
+program.addCommand(contextTypesCommand());
+program.addCommand(briefingCommand());
+program.addCommand(helpCommand());
+program.command("login").description("Sign in to a CRMy server (shortcut for `crmy auth login`)").option("-e, --email <email>", "Email address").option("-p, --password <password>", "Password").action(async (opts) => {
+  const args = ["auth", "login"];
+  if (opts.email) args.push("-e", opts.email);
+  if (opts.password) args.push("-p", opts.password);
+  await program.parseAsync(["node", "crmy", ...args]);
+});
+program.parse();