airchat 0.3.0 → 1.0.0

package/dist/index.js

@@ -14,7 +14,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -1150,8 +1154,8 @@ var require_command = __commonJS({
   "../../node_modules/commander/lib/command.js"(exports) {
     var EventEmitter = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
-    var path3 = __require("node:path");
-    var fs3 = __require("node:fs");
+    var path5 = __require("node:path");
+    var fs5 = __require("node:fs");
     var process2 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -2132,7 +2136,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} subcommandName
        */
       _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-        if (fs3.existsSync(executableFile)) return;
+        if (fs5.existsSync(executableFile)) return;
         const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
         const executableMissing = `'${executableFile}' does not exist
  - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
@@ -2150,11 +2154,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path3.resolve(baseDir, baseName);
-          if (fs3.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path3.extname(baseName))) return void 0;
+          const localBin = path5.resolve(baseDir, baseName);
+          if (fs5.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path5.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs3.existsSync(`${localBin}${ext}`)
+            (ext) => fs5.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -2166,21 +2170,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs3.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path3.resolve(
-            path3.dirname(resolvedScriptPath),
+          executableDir = path5.resolve(
+            path5.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path3.basename(
+            const legacyName = path5.basename(
               this._scriptPath,
-              path3.extname(this._scriptPath)
+              path5.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2191,7 +2195,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path3.extname(executableFile));
+        launchWithNode = sourceExt.includes(path5.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -3038,7 +3042,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path3.basename(filename, path3.extname(filename));
+        this._name = path5.basename(filename, path5.extname(filename));
         return this;
       }
       /**
@@ -3052,9 +3056,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path4) {
-        if (path4 === void 0) return this._executableDir;
-        this._executableDir = path4;
+      executableDir(path6) {
+        if (path6 === void 0) return this._executableDir;
+        this._executableDir = path6;
         return this;
       }
       /**
@@ -3327,13 +3331,13 @@ var require_commander = __commonJS({
 });
 
 // src/index.ts
-import * as readline from "node:readline/promises";
+import * as readline2 from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import * as os2 from "node:os";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
+import * as os3 from "node:os";
 import * as crypto2 from "node:crypto";
-import { execSync } from "node:child_process";
+import { execSync as execSync2 } from "node:child_process";
 import { createClient } from "@supabase/supabase-js";
 
 // ../../node_modules/commander/esm.mjs
@@ -3395,6 +3399,85 @@ function generateNonce() {
   return crypto.randomBytes(16).toString("hex");
 }
 
+// ../shared/dist/agent-card.js
+var MAX_CAPABILITIES = 20;
+var MAX_TAG_LENGTH = 50;
+var MAX_FIELD_LENGTH = 100;
+var TAG_PATTERN = /^[a-z0-9][a-z0-9-]{0,49}$/;
+function validateCard(input2) {
+  if (typeof input2 !== "object" || input2 === null || Array.isArray(input2)) {
+    return { ok: false, error: "card must be an object" };
+  }
+  const raw = input2;
+  const card = {};
+  for (const field of ["model", "harness"]) {
+    const value = raw[field];
+    if (value === void 0 || value === null)
+      continue;
+    if (typeof value !== "string") {
+      return { ok: false, error: `card.${field} must be a string` };
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+      continue;
+    if (trimmed.length > MAX_FIELD_LENGTH) {
+      return { ok: false, error: `card.${field} must be at most ${MAX_FIELD_LENGTH} characters` };
+    }
+    if (/[\x00-\x1f\x7f]/.test(trimmed)) {
+      return { ok: false, error: `card.${field} contains control characters` };
+    }
+    card[field] = trimmed;
+  }
+  const capabilities = raw.capabilities;
+  if (capabilities !== void 0 && capabilities !== null) {
+    if (!Array.isArray(capabilities)) {
+      return { ok: false, error: "card.capabilities must be an array of strings" };
+    }
+    if (capabilities.length > MAX_CAPABILITIES) {
+      return { ok: false, error: `card.capabilities must have at most ${MAX_CAPABILITIES} tags` };
+    }
+    const cleaned = [];
+    for (const tag of capabilities) {
+      if (typeof tag !== "string") {
+        return { ok: false, error: "card.capabilities must be an array of strings" };
+      }
+      const trimmed = tag.trim().toLowerCase();
+      if (trimmed.length === 0)
+        continue;
+      if (trimmed.length > MAX_TAG_LENGTH || !TAG_PATTERN.test(trimmed)) {
+        return {
+          ok: false,
+          error: `capability tag "${trimmed.slice(0, 60)}" must be kebab-case (lowercase alphanumeric and hyphens, max ${MAX_TAG_LENGTH} chars)`
+        };
+      }
+      if (!cleaned.includes(trimmed))
+        cleaned.push(trimmed);
+    }
+    if (cleaned.length > 0)
+      card.capabilities = cleaned;
+  }
+  if (card.model === void 0 && card.harness === void 0 && card.capabilities === void 0) {
+    return { ok: false, error: "card must declare at least one of model, harness, capabilities" };
+  }
+  return { ok: true, card };
+}
+function cardFromEnv(env = process.env) {
+  const model = env.AIRCHAT_MODEL;
+  const harness = env.AIRCHAT_HARNESS;
+  const capabilitiesRaw = env.AIRCHAT_CAPABILITIES;
+  if (!model && !harness && !capabilitiesRaw)
+    return null;
+  const result = validateCard({
+    model,
+    harness,
+    capabilities: capabilitiesRaw ? capabilitiesRaw.split(",") : void 0
+  });
+  if (!result.ok) {
+    throw new Error(`Invalid agent card from environment: ${result.error}`);
+  }
+  return result.card;
+}
+
 // ../shared/dist/rest-client.js
 var DEFAULT_AIRCHAT_URL = "https://supernode-web-production.up.railway.app";
 function unwrapEnvelope(body) {
@@ -3409,17 +3492,22 @@ var AirChatRestClient = class _AirChatRestClient {
   privateKeyHex;
   agentName;
   cacheDir;
+  card;
   derivedKey = null;
   registering = null;
   constructor(config) {
     if (!/^https?:\/\//i.test(config.webUrl)) {
       throw new Error(`Invalid AIRCHAT_WEB_URL: "${config.webUrl}" \u2014 must start with http:// or https://`);
     }
-    this.webUrl = config.webUrl.replace(/\/+$/, "");
+    let webUrl = config.webUrl;
+    while (webUrl.endsWith("/"))
+      webUrl = webUrl.slice(0, -1);
+    this.webUrl = webUrl;
     this.machineName = config.machineName;
     this.privateKeyHex = config.privateKeyHex;
     this.agentName = config.agentName;
     this.cacheDir = config.cacheDir ?? path.join(os.homedir(), ".airchat", "agents");
+    this.card = config.card ?? null;
     this.checkPermissions();
   }
   // ── Public: identity ────────────────────────────────────────────────────
@@ -3431,8 +3519,60 @@ var AirChatRestClient = class _AirChatRestClient {
     return this.request("GET", "/api/v2/board");
   }
   // ── Public: agents ─────────────────────────────────────────────────────
-  async listAgents() {
-    return this.request("GET", "/api/v2/agents");
+  async listAgents(capability, activeWithin) {
+    const params = new URLSearchParams();
+    if (capability)
+      params.set("capability", capability);
+    if (activeWithin)
+      params.set("active_within", activeWithin);
+    return this.request("GET", "/api/v2/agents", params);
+  }
+  /**
+   * Update this agent's capability card on the server. Registration already
+   * sends the card, but registration is skipped while a cached derived key
+   * exists — this is the explicit path for card changes mid-life.
+   */
+  async setCard(card) {
+    return this.request("POST", "/api/v2/agents/card", void 0, { card });
+  }
+  /**
+   * Everything waiting for this agent in one call: unread mentions, open
+   * tasks matching its card, its claimed tasks, and completions of tasks it
+   * posted (since the given ISO timestamp; default last 24h).
+   */
+  async checkWork(since) {
+    const params = new URLSearchParams();
+    if (since)
+      params.set("since", since);
+    return this.request("GET", "/api/v2/work", params);
+  }
+  // ── Public: tasks ──────────────────────────────────────────────────────
+  async postTask(channel, title, body, capabilityTags) {
+    return this.request("POST", "/api/v2/tasks", void 0, {
+      channel,
+      title,
+      body,
+      capability_tags: capabilityTags
+    });
+  }
+  async listTasks(opts) {
+    const params = new URLSearchParams();
+    if (opts?.status)
+      params.set("status", opts.status);
+    if (opts?.capability)
+      params.set("capability", opts.capability);
+    if (opts?.mine)
+      params.set("mine", opts.mine);
+    if (opts?.channel)
+      params.set("channel", opts.channel);
+    if (opts?.forMe)
+      params.set("for_me", "1");
+    if (opts?.limit !== void 0)
+      params.set("limit", String(opts.limit));
+    return this.request("GET", "/api/v2/tasks", params);
+  }
+  async updateTask(taskId, action, result) {
+    return this.request("POST", `/api/v2/tasks/${encodeURIComponent(taskId)}`, void 0, { action, result });
   }
   // ── Public: channels ────────────────────────────────────────────────────
   async listChannels(type) {
@@ -3622,7 +3762,8 @@ var AirChatRestClient = class _AirChatRestClient {
       machineName,
       privateKeyHex,
       agentName,
-      cacheDir: overrides?.cacheDir
+      cacheDir: overrides?.cacheDir,
+      card: overrides?.card !== void 0 ? overrides.card : cardFromEnv()
     });
   }
   // ── Internal: HTTP request with auth ────────────────────────────────────
@@ -3697,7 +3838,7 @@ var AirChatRestClient = class _AirChatRestClient {
     const res = await fetch(url, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ ...payload, signature }),
+      body: JSON.stringify({ ...payload, signature, ...this.card ? { card: this.card } : {} }),
       signal: AbortSignal.timeout(15e3)
     });
     if (res.status === 409) {
@@ -3816,6 +3957,82 @@ async function post(client, channelName, content, parentMessageId) {
   }
 }
 
+// ../cli/dist/commands/dm.js
+async function dm(client, targetAgent, content) {
+  const target = targetAgent.replace(/^@/, "");
+  if (!target) {
+    console.error("Usage: airchat dm <agent> <message>");
+    process.exitCode = 1;
+    return;
+  }
+  if (!content.trim()) {
+    console.error("Refusing to send an empty message.");
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    await client.sendDirectMessage(target, content);
+    console.log(`
+\u2713 DM sent to @${target}
+`);
+    console.log("  They will see it on their next prompt, via the mention hook.");
+    console.log("  See who else is around with:  airchat agents\n");
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(`
+\u2717 Could not DM @${target}: ${message}`);
+    console.error("  Check the name with:  airchat agents\n");
+    process.exitCode = 1;
+  }
+}
+
+// ../cli/dist/commands/whoami.js
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+import * as fs2 from "node:fs";
+function whoami() {
+  const airchatDir = path2.join(os2.homedir(), ".airchat");
+  let machineName = "";
+  try {
+    for (const line of fs2.readFileSync(path2.join(airchatDir, "config"), "utf-8").split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#"))
+        continue;
+      const eq = trimmed.indexOf("=");
+      if (eq === -1)
+        continue;
+      if (trimmed.slice(0, eq).trim() === "MACHINE_NAME") {
+        machineName = trimmed.slice(eq + 1).trim();
+      }
+    }
+  } catch {
+    console.error("\nNo ~/.airchat/config found \u2014 this machine is not set up. Run: npx airchat\n");
+    process.exitCode = 1;
+    return;
+  }
+  if (!machineName) {
+    console.error("\nMACHINE_NAME is not set in ~/.airchat/config.\n");
+    process.exitCode = 1;
+    return;
+  }
+  const project = path2.basename(process.cwd());
+  const agentName = `${machineName}-${project}`;
+  const keyPath = path2.join(airchatDir, "agents", `${agentName}.key`);
+  const registered = fs2.existsSync(keyPath);
+  console.log("");
+  console.log(`  Agent name:   ${agentName}`);
+  console.log(`  Machine:      ${machineName}`);
+  console.log(`  Project dir:  ${process.cwd()}`);
+  console.log(`  Registered:   ${registered ? "yes" : "not yet \u2014 registers on first check"}`);
+  console.log("");
+  console.log(`  Others reach you at:  @${agentName}`);
+  console.log(`  They would send:      airchat dm ${agentName} "..."`);
+  console.log("");
+  console.log("  The name comes from the directory you are running in, so the same");
+  console.log("  machine runs a different agent per project.");
+  console.log("");
+}
+
 // ../cli/dist/commands/search.js
 async function search(client, queryText, channelName) {
   const data = await client.searchMessages(queryText, channelName);
@@ -3872,6 +4089,195 @@ async function channels(client, type) {
   console.log("");
 }
 
+// ../cli/dist/commands/agents.js
+import * as readline from "node:readline";
+import * as readlinePromises from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+var PAGE = 5;
+async function agents(client, capability, activeWithin, opts = {}) {
+  const data = await client.listAgents(capability, activeWithin);
+  const list = data.agents ?? [];
+  const filter = [
+    capability ? ` with capability "${capability}"` : "",
+    activeWithin ? ` seen within ${activeWithin}` : ""
+  ].join("");
+  if (list.length === 0) {
+    console.log(`
+\u{1F916} No agents${filter}.
+`);
+    if (activeWithin)
+      console.log("  Try a wider window:  airchat agents -w 7d\n");
+    return;
+  }
+  const canPick = opts.interactive !== false && stdout.isTTY && stdin.isTTY;
+  if (!canPick) {
+    console.log(`
+\u{1F916} Agents${filter} (${list.length})
+`);
+    for (const a of list)
+      console.log(describe(a));
+    console.log("");
+    return;
+  }
+  await pick(client, list, filter);
+}
+function ageOf(a) {
+  if (!a.last_seen_at)
+    return "never seen";
+  const ms = Date.now() - new Date(a.last_seen_at).getTime();
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 1)
+    return "just now";
+  if (mins < 60)
+    return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24)
+    return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+function cardLine(a) {
+  const parts = [];
+  if (a.machine)
+    parts.push(a.machine);
+  if (a.card?.harness)
+    parts.push(a.card.harness);
+  if (a.card?.model)
+    parts.push(a.card.model);
+  if (a.card?.capabilities?.length)
+    parts.push(a.card.capabilities.join(", "));
+  return parts.join(" \xB7 ");
+}
+function describe(a) {
+  const card = cardLine(a);
+  return `  ${a.name.padEnd(30)} ${ageOf(a).padEnd(10)}${card}`;
+}
+async function pick(client, list, filter) {
+  let cursor = 0;
+  let offset = 0;
+  let lastLines = 0;
+  const render = () => {
+    if (lastLines > 0)
+      stdout.write(`\x1B[${lastLines}A\x1B[0J`);
+    const page = list.slice(offset, offset + PAGE);
+    const out = [];
+    out.push(`\u{1F916} Agents${filter} \u2014 ${offset + 1}\u2013${offset + page.length} of ${list.length}`);
+    out.push("");
+    page.forEach((a, i) => {
+      const selected = offset + i === cursor;
+      const card = cardLine(a);
+      out.push(`${selected ? "\x1B[36m\u276F\x1B[0m " : "  "}${selected ? "\x1B[1m" : ""}${a.name.padEnd(30)}${selected ? "\x1B[0m" : ""} \x1B[2m${ageOf(a).padEnd(10)}${card}\x1B[0m`);
+    });
+    out.push("");
+    out.push("\x1B[2m  \u2191/\u2193 move \xB7 enter message \xB7 n/p page \xB7 q quit\x1B[0m");
+    stdout.write(out.join("\n") + "\n");
+    lastLines = out.length;
+  };
+  readline.emitKeypressEvents(stdin);
+  if (stdin.isTTY)
+    stdin.setRawMode(true);
+  render();
+  const chosen = await new Promise((resolve) => {
+    const onKey = (_s, key) => {
+      if (!key)
+        return;
+      const done = (value) => {
+        stdin.off("keypress", onKey);
+        if (stdin.isTTY)
+          stdin.setRawMode(false);
+        resolve(value);
+      };
+      if (key.name === "q" || key.ctrl && key.name === "c")
+        return done(null);
+      if (key.name === "return")
+        return done(list[cursor]);
+      if (key.name === "down")
+        cursor = Math.min(cursor + 1, list.length - 1);
+      else if (key.name === "up")
+        cursor = Math.max(cursor - 1, 0);
+      else if (key.name === "n")
+        cursor = Math.min(offset + PAGE, list.length - 1);
+      else if (key.name === "p")
+        cursor = Math.max(offset - PAGE, 0);
+      else
+        return;
+      if (cursor < offset)
+        offset = Math.max(0, cursor - cursor % PAGE);
+      if (cursor >= offset + PAGE)
+        offset = cursor - cursor % PAGE;
+      render();
+    };
+    stdin.on("keypress", onKey);
+  });
+  if (!chosen) {
+    console.log("");
+    return;
+  }
+  const rl = readlinePromises.createInterface({ input: stdin, output: stdout });
+  const message = (await rl.question(`
+Message to @${chosen.name}: `)).trim();
+  rl.close();
+  if (!message) {
+    console.log("\nNothing sent.\n");
+    return;
+  }
+  try {
+    await client.sendDirectMessage(chosen.name, message);
+    console.log(`
+\u2713 Sent to @${chosen.name}`);
+    console.log("  They see it on their next prompt, via the mention hook.\n");
+  } catch (e) {
+    console.error(`
+\u2717 Not sent: ${e instanceof Error ? e.message : String(e)}
+`);
+    process.exitCode = 1;
+  }
+}
+
+// ../cli/dist/commands/tasks.js
+function printTask(task) {
+  const tags = task.capability_tags.length ? ` [${task.capability_tags.join(", ")}]` : "";
+  console.log(`  ${task.id.slice(0, 8)}  ${task.status.padEnd(9)} ${task.title}${tags}`);
+  if (task.result && task.status === "done") {
+    const firstLine = task.result.split("\n")[0];
+    console.log(`            \u2192 ${firstLine.slice(0, 100)}`);
+  }
+}
+async function tasksList(client, opts) {
+  const hasFilter = opts.status || opts.capability || opts.mine || opts.channel;
+  if (!hasFilter) {
+    const data2 = await client.listTasks({ forMe: true });
+    console.log(`
+\u{1F4CB} Open tasks matching your card (${data2.open_matching.length})
+`);
+    data2.open_matching.forEach(printTask);
+    console.log(`
+\u{1F4CC} Your claimed tasks (${data2.mine_claimed.length})
+`);
+    data2.mine_claimed.forEach(printTask);
+    console.log("");
+    return;
+  }
+  const data = await client.listTasks(opts);
+  console.log(`
+\u{1F4CB} Tasks (${data.tasks.length})
+`);
+  data.tasks.forEach(printTask);
+  console.log("");
+}
+async function tasksPost(client, channel, title, opts) {
+  const tags = opts.tags ? opts.tags.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
+  const data = await client.postTask(channel, title, opts.body, tags);
+  console.log(`
+\u2713 Task posted to #${channel}: ${data.task.id}
+`);
+}
+async function tasksUpdate(client, id, action, result) {
+  const data = await client.updateTask(id, action, result);
+  console.log(`
+\u2713 Task ${data.task.id.slice(0, 8)} \u2192 ${data.task.status}
+`);
+}
+
 // ../cli/dist/commands/gossip.js
 async function gossipEnable(client) {
   try {
@@ -3990,17 +4396,17 @@ async function peerList(client) {
 }
 
 // ../cli/dist/commands/doctor.js
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 async function doctor() {
-  const configDir = join(homedir(), ".airchat");
+  const configDir = join2(homedir2(), ".airchat");
   const checks = [];
   let machineName;
   let webUrl;
   let privateKey;
   console.log("\n\u{1FA7A} AirChat Doctor\n");
-  if (existsSync(configDir)) {
+  if (existsSync2(configDir)) {
     checks.push({ name: "Config directory", status: "pass", message: configDir });
   } else {
     checks.push({ name: "Config directory", status: "fail", message: `Missing ${configDir}` });
@@ -4008,10 +4414,10 @@ async function doctor() {
     printFix(['Run "npx airchat" to set up AirChat.']);
     return;
   }
-  const configPath = join(configDir, "config");
-  if (existsSync(configPath)) {
+  const configPath = join2(configDir, "config");
+  if (existsSync2(configPath)) {
     try {
-      const lines = readFileSync(configPath, "utf-8").split("\n");
+      const lines = readFileSync2(configPath, "utf-8").split("\n");
       for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#"))
@@ -4044,10 +4450,10 @@ async function doctor() {
     webUrl = DEFAULT_AIRCHAT_URL;
     checks.push({ name: "AIRCHAT_WEB_URL", status: "warn", message: `Not set \u2014 using default: ${DEFAULT_AIRCHAT_URL}` });
   }
-  const keyPath = join(configDir, "machine.key");
-  if (existsSync(keyPath)) {
+  const keyPath = join2(configDir, "machine.key");
+  if (existsSync2(keyPath)) {
     try {
-      privateKey = readFileSync(keyPath, "utf-8").trim();
+      privateKey = readFileSync2(keyPath, "utf-8").trim();
       if (privateKey.length > 0) {
         checks.push({ name: "Machine key", status: "pass", message: `${keyPath} (${privateKey.length} chars)` });
       } else {
@@ -4086,7 +4492,7 @@ async function doctor() {
   printChecks(checks);
   const fixes = [];
   const hasFail = checks.some((c) => c.status === "fail");
-  if (!existsSync(configPath) || !machineName || !existsSync(keyPath)) {
+  if (!existsSync2(configPath) || !machineName || !existsSync2(keyPath)) {
     fixes.push('Run "npx airchat" to set up machine credentials.');
   }
   if (checks.find((c) => c.name === "Server connectivity" && c.status === "fail")) {
@@ -4116,7 +4522,7 @@ function printFix(fixes) {
 }
 
 // ../cli/dist/commands/notes.js
-import { readFileSync as readFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3 } from "node:fs";
 function parseScope(scope) {
   if (scope === "global")
     return null;
@@ -4130,10 +4536,10 @@ function resolveBody(opts) {
   if (opts.body !== void 0)
     return opts.body;
   if (opts.bodyFile)
-    return readFileSync2(opts.bodyFile, "utf8");
+    return readFileSync3(opts.bodyFile, "utf8");
   if (!process.stdin.isTTY) {
     try {
-      return readFileSync2(0, "utf8");
+      return readFileSync3(0, "utf8");
     } catch {
     }
   }
@@ -4244,9 +4650,18 @@ async function run(argv = process.argv) {
   program2.command("check").description("Show unread counts and latest message per channel").action(() => check(client));
   program2.command("read <channel>").description("Read recent messages from a channel").option("-l, --limit <n>", "Number of messages", "20").action((channel, opts) => read(client, channel, parseInt(opts.limit, 10)));
   program2.command("post <channel> <message>").description("Post a message to a channel").option("-t, --thread <id>", "Reply to a message (thread)").action((channel, message, opts) => post(client, channel, message, opts.thread));
+  program2.command("whoami").description("Show this agent's AirChat name \u2014 what others use to message it").action(() => whoami());
+  program2.command("dm <agent> <message...>").description("Send a direct message to another agent (notifies them)").action((agent, messageParts) => dm(client, agent, messageParts.join(" ")));
   program2.command("search <query>").description("Search messages across channels").option("-c, --channel <name>", "Restrict to a channel").action((query, opts) => search(client, query, opts.channel));
   program2.command("status").description("Show channel memberships, roles, and unread counts").action(() => status(client));
   program2.command("channels").description("List all available channels").option("-t, --type <type>", "Filter by channel type").action((opts) => channels(client, opts.type));
+  program2.command("agents").description("List agents you can message (default: seen in the last day)").option("-c, --capability <tag>", "Filter by capability tag, e.g. image-gen").option("-w, --active-within <window>", "Window: 15m|1h|6h|1d|7d", "1d").option("-a, --all", "Include every registered agent, however long dead").option("--no-interactive", "Plain list, no picker (implied when not a terminal)").action((opts) => agents(client, opts.capability, opts.all ? void 0 : opts.activeWithin, { all: opts.all, interactive: opts.interactive }));
+  const tasks = program2.command("tasks").description("Capability-tagged task queue");
+  tasks.command("list", { isDefault: true }).description("List tasks (no filters: open tasks matching your card + your claims)").option("-s, --status <status>", "open | claimed | done | cancelled").option("-c, --capability <tag>", "Filter by capability tag").option("-m, --mine <side>", "created | claimed").option("--channel <name>", "Filter by channel").action((opts) => tasksList(client, opts));
+  tasks.command("post <channel> <title>").description("Post a task for another agent to claim").option("-b, --body <text>", "Task details").option("-t, --tags <tags>", "Comma-separated capability tags, e.g. image-gen,vision").action((channel, title, opts) => tasksPost(client, channel, title, opts));
+  tasks.command("claim <id>").description("Claim an open task (atomic \u2014 one winner)").action((id) => tasksUpdate(client, id, "claim"));
+  tasks.command("complete <id> <result>").description("Complete a task you claimed; the result is posted to the channel").action((id, result) => tasksUpdate(client, id, "complete", result));
+  tasks.command("cancel <id>").description("Cancel a task you created").action((id) => tasksUpdate(client, id, "cancel"));
   program2.command("notes [channel]").description("List notes in a channel, or across all channels + global if omitted").option("-s, --search <query>", "Full-text search within notes").option("--stubs", "Include unfilled stubs").option("-l, --limit <n>", "Max notes to list").action((channel, opts) => notesList(client, channel, opts));
   program2.command("note <scope> <slug>").description('Read a note. <scope> is a channel name or "global"').option("-r, --revision <n>", "Read a specific past revision").action((scope, slug, opts) => noteRead(client, scope, slug, opts));
   program2.command("write-note <scope> <slug>").description("Create or update a note. Body from --body, --body-file, or stdin").option("-t, --title <title>", "Note title (defaults to the slug)").option("-b, --body <text>", "Note body (Markdown)").option("-f, --body-file <path>", "Read the body from a file").option("--protect", "Mark the note protected (creator-only writes)").option("--expected-revision <n>", "Optimistic concurrency: fail if the note moved on").action((scope, slug, opts) => noteWrite(client, scope, slug, opts));
@@ -4263,7 +4678,194 @@ async function run(argv = process.argv) {
   await program2.parseAsync(argv);
 }
 
+// src/harnesses.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import { execSync } from "node:child_process";
+function binaryExists(bin) {
+  try {
+    execSync(process.platform === "win32" ? `where ${bin}` : `command -v ${bin}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fwd(p) {
+  return p.replace(/\\/g, "/");
+}
+function launchParts(launch) {
+  return {
+    command: fwd(launch.nodePath),
+    args: [fwd(launch.tsxPath), fwd(launch.serverPath)]
+  };
+}
+function readIfExists(filePath) {
+  try {
+    return fs3.readFileSync(filePath, "utf-8");
+  } catch (e) {
+    if (e?.code === "ENOENT") return null;
+    throw e;
+  }
+}
+function mergeJsonFile(filePath, mutate, manualSnippet) {
+  let config = {};
+  const raw = readIfExists(filePath);
+  if (raw !== null && raw.trim()) {
+    try {
+      config = JSON.parse(raw);
+    } catch {
+      return {
+        ok: false,
+        message: `${filePath} exists but could not be parsed (comments or trailing commas?). Left untouched \u2014 add the entry manually:`,
+        manualSnippet
+      };
+    }
+  }
+  mutate(config);
+  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs3.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n");
+  return { ok: true, message: filePath };
+}
+function tryCliRegister(cmd, manualSnippet) {
+  try {
+    execSync(cmd, { stdio: "pipe" });
+    return { ok: true, message: "Registered via CLI" };
+  } catch {
+    return {
+      ok: false,
+      message: `Could not run "${cmd.split(" ").slice(0, 3).join(" ")} \u2026". Add manually:`,
+      manualSnippet
+    };
+  }
+}
+var HARNESSES = [
+  {
+    key: "claude",
+    label: "Claude Code",
+    instructionsPath: (home) => path3.join(home, ".claude", "CLAUDE.md"),
+    detect: (home, hasBinary) => fs3.existsSync(path3.join(home, ".claude")) || hasBinary("claude"),
+    registerMcp(launch) {
+      const { command, args } = launchParts(launch);
+      const cmd = `claude mcp add airchat -s user -- "${command}" ${args.map((a) => `"${a}"`).join(" ")}`;
+      return tryCliRegister(cmd, cmd);
+    }
+  },
+  {
+    key: "codex",
+    label: "Codex CLI",
+    instructionsPath: (home) => path3.join(home, ".codex", "AGENTS.md"),
+    detect: (home, hasBinary) => fs3.existsSync(path3.join(home, ".codex")) || hasBinary("codex"),
+    registerMcp(launch) {
+      const { command, args } = launchParts(launch);
+      const cmd = `codex mcp add airchat -- "${command}" ${args.map((a) => `"${a}"`).join(" ")}`;
+      const toml = [
+        "# ~/.codex/config.toml",
+        "[mcp_servers.airchat]",
+        `command = "${command}"`,
+        `args = [${args.map((a) => `"${a}"`).join(", ")}]`
+      ].join("\n");
+      return tryCliRegister(cmd, toml);
+    }
+  },
+  {
+    key: "antigravity",
+    label: "Antigravity CLI (formerly Gemini CLI)",
+    // Both GEMINI.md and AGENTS.md are honored; GEMINI.md is the long-standing
+    // global location so existing setups keep working.
+    instructionsPath: (home) => path3.join(home, ".gemini", "GEMINI.md"),
+    detect: (home, hasBinary) => fs3.existsSync(path3.join(home, ".gemini", "config")) || hasBinary("agy") || hasBinary("gemini"),
+    registerMcp(launch, home) {
+      const { command, args } = launchParts(launch);
+      const filePath = path3.join(home, ".gemini", "config", "mcp_config.json");
+      const snippet = JSON.stringify({ mcpServers: { airchat: { command, args } } }, null, 2);
+      return mergeJsonFile(
+        filePath,
+        (config) => {
+          config.mcpServers = config.mcpServers ?? {};
+          config.mcpServers.airchat = { command, args };
+        },
+        `// ${filePath}
+${snippet}`
+      );
+    }
+  },
+  {
+    key: "cursor",
+    label: "Cursor",
+    // Cursor's global rules live in app settings, not a file; project-level
+    // AGENTS.md is out of scope for a global installer.
+    instructionsPath: null,
+    detect: (home, hasBinary) => fs3.existsSync(path3.join(home, ".cursor")) || hasBinary("cursor-agent"),
+    registerMcp(launch, home) {
+      const { command, args } = launchParts(launch);
+      const filePath = path3.join(home, ".cursor", "mcp.json");
+      const entry = { type: "stdio", command, args };
+      const snippet = JSON.stringify({ mcpServers: { airchat: entry } }, null, 2);
+      return mergeJsonFile(
+        filePath,
+        (config) => {
+          config.mcpServers = config.mcpServers ?? {};
+          config.mcpServers.airchat = entry;
+        },
+        `// ${filePath}
+${snippet}`
+      );
+    }
+  },
+  {
+    key: "opencode",
+    label: "OpenCode",
+    instructionsPath: (home) => path3.join(home, ".config", "opencode", "AGENTS.md"),
+    detect: (home, hasBinary) => fs3.existsSync(path3.join(home, ".config", "opencode")) || hasBinary("opencode"),
+    registerMcp(launch, home) {
+      const { command, args } = launchParts(launch);
+      const filePath = path3.join(home, ".config", "opencode", "opencode.json");
+      const entry = { type: "local", command: [command, ...args], enabled: true };
+      const snippet = JSON.stringify({ mcp: { airchat: entry } }, null, 2);
+      return mergeJsonFile(
+        filePath,
+        (config) => {
+          config.mcp = config.mcp ?? {};
+          config.mcp.airchat = entry;
+        },
+        `// ${filePath}
+${snippet}`
+      );
+    }
+  }
+];
+function detectHarnesses(home, hasBinary = binaryExists) {
+  return HARNESSES.filter((h) => h.detect(home, hasBinary));
+}
+function genericSnippet(launch) {
+  const { command, args } = launchParts(launch);
+  return [
+    "AirChat is a standard stdio MCP server. For any other MCP client, register:",
+    `  command: ${command}`,
+    `  args:    ${args.join(" ")}`,
+    "  env:     none (reads ~/.airchat/config and ~/.airchat/machine.key)"
+  ].join("\n");
+}
+function installInstructions(filePath, content) {
+  try {
+    const existing = readIfExists(filePath);
+    if (existing !== null) {
+      if (existing.includes("# AirChat")) {
+        return { ok: true, message: `Already present in ${filePath}` };
+      }
+      fs3.appendFileSync(filePath, "\n" + content);
+    } else {
+      fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+      fs3.writeFileSync(filePath, content);
+    }
+    return { ok: true, message: filePath };
+  } catch (e) {
+    return { ok: false, message: e.message };
+  }
+}
+
 // src/index.ts
+var AIRCHAT_VERSION = true ? "1.0.0" : "dev";
 var DEFAULT_AIRCHAT_URL2 = "https://supernode-web-production.up.railway.app";
 var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
@@ -4287,10 +4889,10 @@ function bold(msg) {
   return `${BOLD}${msg}${RESET}`;
 }
 function readExistingConfig() {
-  const configPath = path2.join(os2.homedir(), ".airchat", "config");
+  const configPath = path4.join(os3.homedir(), ".airchat", "config");
   const config = {};
   try {
-    const lines = fs2.readFileSync(configPath, "utf-8").split("\n");
+    const lines = fs4.readFileSync(configPath, "utf-8").split("\n");
     for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -4308,10 +4910,10 @@ function detectNodePath() {
 function detectRepoDir() {
   let dir = process.cwd();
   for (let i = 0; i < 10; i++) {
-    if (fs2.existsSync(path2.join(dir, "packages", "mcp-server", "src", "index.ts"))) {
+    if (fs4.existsSync(path4.join(dir, "packages", "mcp-server", "src", "index.ts"))) {
       return dir;
     }
-    const parent = path2.dirname(dir);
+    const parent = path4.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4382,7 +4984,7 @@ async function collectConfig(rl, reconfigure) {
     console.log(`  ${dim("A PostgreSQL container will be started alongside the dashboard.")}`);
     console.log("");
   }
-  const defaultMachine = existing.MACHINE_NAME || os2.hostname().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "laptop";
+  const defaultMachine = existing.MACHINE_NAME || os3.hostname().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "laptop";
   let machineName = "";
   while (!machineName) {
     machineName = await ask(rl, "Machine name (e.g. laptop, server, nas)", defaultMachine);
@@ -4392,6 +4994,21 @@ async function collectConfig(rl, reconfigure) {
     }
   }
   console.log("");
+  const detected = detectHarnesses(os3.homedir());
+  const detectedKeys = new Set(detected.map((h) => h.key));
+  console.log("  Which AI harnesses should connect to AirChat?");
+  HARNESSES.forEach((h, i) => {
+    const mark = detectedKeys.has(h.key) ? ` ${GREEN}(detected)${RESET}` : "";
+    console.log(`    ${BOLD}${i + 1}${RESET}) ${h.label}${mark}`);
+  });
+  console.log(`    ${BOLD}${HARNESSES.length + 1}${RESET}) Other MCP client ${dim("(prints a generic snippet)")}`);
+  const fallbackSel = detected.length ? detected.map((h) => h.key) : ["claude"];
+  const selRaw = await rl.question(
+    `  Select, comma-separated ${dim(`(Enter = ${fallbackSel.join(", ")})`)}: `
+  );
+  let harnesses = selRaw.split(",").map((s) => parseInt(s.trim(), 10) - 1).filter((idx) => idx >= 0 && idx <= HARNESSES.length).map((idx) => idx === HARNESSES.length ? "other" : HARNESSES[idx].key);
+  if (harnesses.length === 0) harnesses = fallbackSel;
+  console.log("");
   const deployDashboard = await askYesNo(rl, "Deploy web dashboard?", true);
   let dashboardPort = 3003;
   if (deployDashboard) {
@@ -4428,7 +5045,7 @@ async function collectConfig(rl, reconfigure) {
   if (!airchatDir) {
     const shouldClone = await askYesNo(rl, "Clone the airchat repo?", true);
     if (shouldClone) {
-      const cloneDir = await ask(rl, "Clone to", path2.join(os2.homedir(), "projects", "airchat"));
+      const cloneDir = await ask(rl, "Clone to", path4.join(os3.homedir(), "projects", "airchat"));
       airchatDir = cloneDir;
     } else {
       airchatDir = await ask(rl, "Path to existing airchat repo");
@@ -4455,6 +5072,7 @@ async function collectConfig(rl, reconfigure) {
     supabaseServiceRoleKey,
     databaseUrl,
     machineName,
+    harnesses,
     dashboardPort,
     deployDashboard,
     airchatDir,
@@ -4468,14 +5086,14 @@ async function collectConfig(rl, reconfigure) {
 }
 async function cloneAndInstall(config) {
   const name = "Clone & install";
-  if (fs2.existsSync(path2.join(config.airchatDir, "packages", "mcp-server"))) {
+  if (fs4.existsSync(path4.join(config.airchatDir, "packages", "mcp-server"))) {
     return { name, ok: true, message: "Repo already exists" };
   }
   try {
     console.log(`  Cloning airchat...`);
-    execSync(`git clone https://github.com/prone/airchat.git "${config.airchatDir}"`, { stdio: "pipe" });
+    execSync2(`git clone https://github.com/prone/airchat.git "${config.airchatDir}"`, { stdio: "pipe" });
     console.log(`  Installing dependencies...`);
-    execSync("npm install", { cwd: config.airchatDir, stdio: "pipe" });
+    execSync2("npm install", { cwd: config.airchatDir, stdio: "pipe" });
     return { name, ok: true, message: "Cloned and installed" };
   } catch (e) {
     return { name, ok: false, message: `Failed: ${e.message}` };
@@ -4490,27 +5108,27 @@ async function runMigrations(config) {
     const supabase = createClient(config.supabaseUrl, config.supabaseServiceRoleKey, {
       auth: { persistSession: false }
     });
-    const { data: agents } = await supabase.from("agents").select("id").limit(1);
-    if (agents !== null) {
+    const { data: agents2 } = await supabase.from("agents").select("id").limit(1);
+    if (agents2 !== null) {
       return { name, ok: true, message: "Tables already exist \u2014 skipping migrations" };
     }
     try {
-      execSync("which supabase", { stdio: "pipe" });
-      execSync(`supabase db push --db-url "${config.supabaseUrl}"`, {
+      execSync2("which supabase", { stdio: "pipe" });
+      execSync2(`supabase db push --db-url "${config.supabaseUrl}"`, {
         cwd: config.airchatDir,
         stdio: "pipe"
       });
       return { name, ok: true, message: "Migrations applied via Supabase CLI" };
     } catch {
     }
-    const migrationsDir = path2.join(config.airchatDir, "supabase", "migrations");
-    if (!fs2.existsSync(migrationsDir)) {
+    const migrationsDir = path4.join(config.airchatDir, "supabase", "migrations");
+    if (!fs4.existsSync(migrationsDir)) {
       return { name, ok: false, message: `Migrations directory not found at ${migrationsDir}` };
     }
-    const files = fs2.readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
+    const files = fs4.readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
     let applied = 0;
     for (const file of files) {
-      const sql = fs2.readFileSync(path2.join(migrationsDir, file), "utf-8");
+      const sql = fs4.readFileSync(path4.join(migrationsDir, file), "utf-8");
       const { error } = await supabase.rpc("", {}).then(
         () => ({ error: null }),
         () => ({ error: null })
@@ -4528,11 +5146,11 @@ async function runMigrations(config) {
     return { name, ok: true, message: "Migrations applied" };
   }
   if (config.dbProvider === "self-hosted" && config.databaseUrl) {
-    const migrationsDir = path2.join(config.airchatDir, "supabase", "migrations");
-    const files = fs2.readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
+    const migrationsDir = path4.join(config.airchatDir, "supabase", "migrations");
+    const files = fs4.readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
     try {
       for (const file of files) {
-        execSync(`psql "${config.databaseUrl}" -f "${path2.join(migrationsDir, file)}"`, { stdio: "pipe" });
+        execSync2(`psql "${config.databaseUrl}" -f "${path4.join(migrationsDir, file)}"`, { stdio: "pipe" });
       }
       return { name, ok: true, message: `Applied ${files.length} migrations` };
     } catch (e) {
@@ -4564,12 +5182,12 @@ async function seedChannels(config) {
 }
 async function generateAndRegisterKeypair(config, reconfigure) {
   const name = "Generate Ed25519 keypair";
-  const configDir = path2.join(os2.homedir(), ".airchat");
-  const privateKeyPath = path2.join(configDir, "machine.key");
-  const publicKeyPath = path2.join(configDir, "machine.pub");
-  if (!reconfigure && fs2.existsSync(privateKeyPath) && fs2.existsSync(publicKeyPath)) {
-    const existingPub = fs2.readFileSync(publicKeyPath, "utf-8").trim();
-    const existingPriv = fs2.readFileSync(privateKeyPath, "utf-8").trim();
+  const configDir = path4.join(os3.homedir(), ".airchat");
+  const privateKeyPath = path4.join(configDir, "machine.key");
+  const publicKeyPath = path4.join(configDir, "machine.pub");
+  if (!reconfigure && fs4.existsSync(privateKeyPath) && fs4.existsSync(publicKeyPath)) {
+    const existingPub = fs4.readFileSync(publicKeyPath, "utf-8").trim();
+    const existingPriv = fs4.readFileSync(privateKeyPath, "utf-8").trim();
     if (existingPub.length === 64 && existingPriv.length === 64) {
       config.keypair = { publicKey: existingPub, privateKey: existingPriv };
       return { name, ok: true, message: "Existing keypair found \u2014 reusing" };
@@ -4577,11 +5195,11 @@ async function generateAndRegisterKeypair(config, reconfigure) {
   }
   const keypair = generateKeypair();
   config.keypair = keypair;
-  fs2.mkdirSync(configDir, { recursive: true, mode: 448 });
-  fs2.writeFileSync(privateKeyPath, keypair.privateKey + "\n", { mode: 384 });
-  fs2.writeFileSync(publicKeyPath, keypair.publicKey + "\n", { mode: 420 });
-  fs2.chmodSync(configDir, 448);
-  fs2.chmodSync(privateKeyPath, 384);
+  fs4.mkdirSync(configDir, { recursive: true, mode: 448 });
+  fs4.writeFileSync(privateKeyPath, keypair.privateKey + "\n", { mode: 384 });
+  fs4.writeFileSync(publicKeyPath, keypair.publicKey + "\n", { mode: 420 });
+  fs4.chmodSync(configDir, 448);
+  fs4.chmodSync(privateKeyPath, 384);
   if (config.dbProvider === "supabase" && config.supabaseUrl && config.supabaseServiceRoleKey) {
     const supabase = createClient(config.supabaseUrl, config.supabaseServiceRoleKey, {
       auth: { persistSession: false }
@@ -4630,8 +5248,8 @@ async function generateAndRegisterKeypair(config, reconfigure) {
 function writeAirchatConfig(config) {
   const name = "Write ~/.airchat/config";
   try {
-    const configDir = path2.join(os2.homedir(), ".airchat");
-    fs2.mkdirSync(configDir, { recursive: true, mode: 448 });
+    const configDir = path4.join(os3.homedir(), ".airchat");
+    fs4.mkdirSync(configDir, { recursive: true, mode: 448 });
     const lines = [
       `MACHINE_NAME=${config.machineName}`
     ];
@@ -4639,11 +5257,11 @@ function writeAirchatConfig(config) {
     if (config.slackBotToken) lines.push(`SLACK_BOT_TOKEN=${config.slackBotToken}`);
     if (config.slackAppToken) lines.push(`SLACK_APP_TOKEN=${config.slackAppToken}`);
     if (config.slackWebhookUrl) lines.push(`SLACK_WEBHOOK_URL=${config.slackWebhookUrl}`);
-    fs2.writeFileSync(path2.join(configDir, "config"), lines.join("\n") + "\n", { mode: 384 });
-    const agentsDir = path2.join(configDir, "agents");
-    fs2.mkdirSync(agentsDir, { recursive: true, mode: 448 });
-    fs2.chmodSync(agentsDir, 448);
-    fs2.chmodSync(configDir, 448);
+    fs4.writeFileSync(path4.join(configDir, "config"), lines.join("\n") + "\n", { mode: 384 });
+    const agentsDir = path4.join(configDir, "agents");
+    fs4.mkdirSync(agentsDir, { recursive: true, mode: 448 });
+    fs4.chmodSync(agentsDir, 448);
+    fs4.chmodSync(configDir, 448);
     return { name, ok: true, message: configDir };
   } catch (e) {
     return { name, ok: false, message: e.message };
@@ -4655,7 +5273,7 @@ function writeWebEnv(config) {
     return { name, ok: true, message: "Skipped" };
   }
   try {
-    const envPath = path2.join(config.airchatDir, "apps", "web", ".env.local");
+    const envPath = path4.join(config.airchatDir, "apps", "web", ".env.local");
     const lines = [];
     if (config.supabaseUrl) {
       lines.push(`NEXT_PUBLIC_SUPABASE_URL=${config.supabaseUrl}`);
@@ -4666,76 +5284,73 @@ function writeWebEnv(config) {
     if (config.databaseUrl) {
       lines.push(`DATABASE_URL=${config.databaseUrl}`);
     }
-    fs2.writeFileSync(envPath, lines.join("\n") + "\n");
+    fs4.writeFileSync(envPath, lines.join("\n") + "\n");
     return { name, ok: true, message: envPath };
   } catch (e) {
     return { name, ok: false, message: e.message };
   }
 }
-function registerMcpServer(config) {
-  const name = "Register MCP server";
-  const tsxPath = path2.join(config.airchatDir, "node_modules", ".bin", "tsx");
-  const serverPath = path2.join(config.airchatDir, "packages", "mcp-server", "src", "index.ts");
-  if (!fs2.existsSync(serverPath)) {
-    return { name, ok: false, message: `MCP server not found at ${serverPath}` };
-  }
-  const cmd = `claude mcp add airchat -s user -- "${config.nodePath}" "${tsxPath}" "${serverPath}"`.replace(/\\/g, "/");
-  try {
-    execSync(cmd, { stdio: "pipe" });
-    return { name, ok: true, message: "Registered at user level (no env vars \u2014 reads from ~/.airchat/)" };
-  } catch (e) {
-    return {
-      name,
-      ok: false,
-      message: `Could not run "claude mcp add". Run manually:
-    ${cmd}`
-    };
+function buildMcpLaunch(config) {
+  const tsxPath = path4.join(config.airchatDir, "node_modules", ".bin", "tsx");
+  const serverPath = path4.join(config.airchatDir, "packages", "mcp-server", "src", "index.ts");
+  if (!fs4.existsSync(serverPath)) return null;
+  return { nodePath: config.nodePath, tsxPath, serverPath };
+}
+function registerMcpServers(config) {
+  const launch = buildMcpLaunch(config);
+  if (!launch) {
+    return [{ name: "Register MCP server", ok: false, message: `MCP server not found under ${config.airchatDir}` }];
+  }
+  const results = [];
+  for (const key of config.harnesses) {
+    if (key === "other") continue;
+    const harness = HARNESSES.find((h) => h.key === key);
+    if (!harness) continue;
+    const res = harness.registerMcp(launch, os3.homedir());
+    const message = res.manualSnippet ? `${res.message}
+${res.manualSnippet.split("\n").map((l) => `    ${l}`).join("\n")}` : res.message;
+    results.push({ name: `MCP \xB7 ${harness.label}`, ok: res.ok, message });
   }
+  return results;
 }
-function installClaudeMd(config) {
-  const name = "Install agent instructions";
-  try {
-    const srcPath = path2.join(config.airchatDir, "setup", "global-CLAUDE.md");
-    if (!fs2.existsSync(srcPath)) {
-      return { name, ok: false, message: "setup/global-CLAUDE.md not found" };
-    }
-    const content = fs2.readFileSync(srcPath, "utf-8");
-    const claudeMdPath = path2.join(os2.homedir(), ".claude", "CLAUDE.md");
-    if (fs2.existsSync(claudeMdPath)) {
-      const existing = fs2.readFileSync(claudeMdPath, "utf-8");
-      if (existing.includes("# AirChat")) {
-        return { name, ok: true, message: "Already present in ~/.claude/CLAUDE.md" };
-      }
-      fs2.appendFileSync(claudeMdPath, "\n" + content);
-    } else {
-      fs2.mkdirSync(path2.dirname(claudeMdPath), { recursive: true });
-      fs2.writeFileSync(claudeMdPath, content);
-    }
-    return { name, ok: true, message: "~/.claude/CLAUDE.md" };
-  } catch (e) {
-    return { name, ok: false, message: e.message };
+function installAgentInstructions(config) {
+  const srcPath = path4.join(config.airchatDir, "setup", "agent-instructions.md");
+  if (!fs4.existsSync(srcPath)) {
+    return [{ name: "Install agent instructions", ok: false, message: "setup/agent-instructions.md not found" }];
+  }
+  const content = fs4.readFileSync(srcPath, "utf-8");
+  const results = [];
+  for (const key of config.harnesses) {
+    const harness = HARNESSES.find((h) => h.key === key);
+    if (!harness?.instructionsPath) continue;
+    const res = installInstructions(harness.instructionsPath(os3.homedir()), content);
+    results.push({ name: `Instructions \xB7 ${harness.label}`, ok: res.ok, message: res.message });
   }
+  return results;
 }
 function installMentionHook(config) {
-  const name = "Install mention hook";
+  const name = "Install work hook";
   try {
-    const settingsPath = path2.join(os2.homedir(), ".claude", "settings.json");
+    const settingsPath = path4.join(os3.homedir(), ".claude", "settings.json");
     let settings = {};
-    if (fs2.existsSync(settingsPath)) {
-      settings = JSON.parse(fs2.readFileSync(settingsPath, "utf-8"));
-    }
-    const hookCommand = `${config.nodePath} ${path2.join(config.airchatDir, "scripts", "check-mentions.mjs")}`.replace(/\\/g, "/");
-    if (settings.hooks?.UserPromptSubmit) {
-      const existing = settings.hooks.UserPromptSubmit;
-      const alreadyHasHook = Array.isArray(existing) && existing.some(
-        (entry) => entry.hooks?.some((h) => h.command?.includes("check-mentions"))
-      );
-      if (alreadyHasHook) {
-        return { name, ok: true, message: "Hook already configured" };
-      }
+    try {
+      settings = JSON.parse(fs4.readFileSync(settingsPath, "utf-8"));
+    } catch (e) {
+      if (e?.code !== "ENOENT") throw e;
     }
+    const hookCommand = `${config.nodePath} ${path4.join(config.airchatDir, "scripts", "check-work.mjs")}`.replace(/\\/g, "/");
     if (!settings.hooks) settings.hooks = {};
     if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
+    settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit.filter(
+      (entry) => !entry.hooks?.some((h) => h.command?.includes("check-mentions"))
+    );
+    const alreadyHasHook = settings.hooks.UserPromptSubmit.some(
+      (entry) => entry.hooks?.some((h) => h.command?.includes("check-work"))
+    );
+    if (alreadyHasHook) {
+      fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      return { name, ok: true, message: "Hook already configured" };
+    }
     settings.hooks.UserPromptSubmit.push({
       matcher: "",
       hooks: [{
@@ -4743,8 +5358,8 @@ function installMentionHook(config) {
         command: hookCommand
       }]
     });
-    fs2.mkdirSync(path2.dirname(settingsPath), { recursive: true });
-    fs2.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    fs4.mkdirSync(path4.dirname(settingsPath), { recursive: true });
+    fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     return { name, ok: true, message: "~/.claude/settings.json" };
   } catch (e) {
     return { name, ok: false, message: e.message };
@@ -4753,12 +5368,12 @@ function installMentionHook(config) {
 function copySlashCommands(config) {
   const name = "Copy slash commands";
   try {
-    const setupDir = path2.join(config.airchatDir, "setup");
-    const commandsDir = path2.join(os2.homedir(), ".claude", "commands");
-    fs2.mkdirSync(commandsDir, { recursive: true });
-    const files = fs2.readdirSync(setupDir).filter((f) => f.startsWith("airchat-") && f.endsWith(".md"));
+    const setupDir = path4.join(config.airchatDir, "setup");
+    const commandsDir = path4.join(os3.homedir(), ".claude", "commands");
+    fs4.mkdirSync(commandsDir, { recursive: true });
+    const files = fs4.readdirSync(setupDir).filter((f) => f.startsWith("airchat-") && f.endsWith(".md"));
     for (const file of files) {
-      fs2.copyFileSync(path2.join(setupDir, file), path2.join(commandsDir, file));
+      fs4.copyFileSync(path4.join(setupDir, file), path4.join(commandsDir, file));
     }
     return { name, ok: true, message: `${files.length} commands \u2192 ~/.claude/commands/` };
   } catch (e) {
@@ -4768,9 +5383,9 @@ function copySlashCommands(config) {
 async function main() {
   const reconfigure = process.argv.includes("--reconfigure");
   console.log("");
-  console.log(`  ${GREEN}>${RESET} ${BOLD}AirChat${RESET} ${dim("v0.3.0")}`);
+  console.log(`  ${GREEN}>${RESET} ${BOLD}AirChat${RESET} ${dim(`v${AIRCHAT_VERSION}`)}`);
   console.log(`  ${dim("Your AI agents can talk to each other")}`);
-  const rl = readline.createInterface({ input, output });
+  const rl = readline2.createInterface({ input, output });
   let config;
   try {
     config = await collectConfig(rl, reconfigure);
@@ -4780,6 +5395,7 @@ async function main() {
   console.log(`  ${bold("Summary:")}`);
   console.log(`    Database:    ${config.dbProvider}`);
   console.log(`    Machine:     ${config.machineName}`);
+  console.log(`    Harnesses:   ${config.harnesses.join(", ")}`);
   console.log(`    Repo:        ${config.airchatDir}`);
   console.log(`    Node:        ${config.nodePath}`);
   if (config.deployDashboard) {
@@ -4827,22 +5443,26 @@ async function main() {
   if (envResult.ok && config.deployDashboard) ok(`Dashboard env \u2192 ${envResult.message}`);
   else if (!config.deployDashboard) {
   } else fail(envResult.message);
-  const mcpResult = registerMcpServer(config);
-  results.push(mcpResult);
-  if (mcpResult.ok) ok(`MCP server \u2192 ${mcpResult.message}`);
-  else warn(mcpResult.message);
-  const claudeResult = installClaudeMd(config);
-  results.push(claudeResult);
-  if (claudeResult.ok) ok(`Instructions \u2192 ${claudeResult.message}`);
-  else fail(claudeResult.message);
-  const hookResult = installMentionHook(config);
-  results.push(hookResult);
-  if (hookResult.ok) ok(`Mention hook \u2192 ${hookResult.message}`);
-  else fail(hookResult.message);
-  const cmdResult = copySlashCommands(config);
-  results.push(cmdResult);
-  if (cmdResult.ok) ok(`Slash commands \u2192 ${cmdResult.message}`);
-  else fail(cmdResult.message);
+  for (const r of registerMcpServers(config)) {
+    results.push(r);
+    if (r.ok) ok(`${r.name} \u2192 ${r.message}`);
+    else warn(`${r.name}: ${r.message}`);
+  }
+  for (const r of installAgentInstructions(config)) {
+    results.push(r);
+    if (r.ok) ok(`${r.name} \u2192 ${r.message}`);
+    else fail(`${r.name}: ${r.message}`);
+  }
+  if (config.harnesses.includes("claude")) {
+    const hookResult = installMentionHook(config);
+    results.push(hookResult);
+    if (hookResult.ok) ok(`Mention hook \u2192 ${hookResult.message}`);
+    else fail(hookResult.message);
+    const cmdResult = copySlashCommands(config);
+    results.push(cmdResult);
+    if (cmdResult.ok) ok(`Slash commands \u2192 ${cmdResult.message}`);
+    else fail(cmdResult.message);
+  }
   console.log("");
   const failures = results.filter((r) => !r.ok);
   if (failures.length === 0) {
@@ -4868,21 +5488,31 @@ async function main() {
   console.log(`    ~/.airchat/machine.key ${dim("Ed25519 private key")}`);
   console.log(`    ~/.airchat/machine.pub ${dim("Ed25519 public key")}`);
   console.log(`    ~/.airchat/agents/     ${dim("Cached derived keys (auto-created)")}`);
+  if (config.harnesses.includes("other")) {
+    const launch = buildMcpLaunch(config);
+    if (launch) {
+      console.log("");
+      console.log(genericSnippet(launch).split("\n").map((l) => `  ${l}`).join("\n"));
+    }
+  }
   console.log("");
   console.log(`  ${dim("Next steps:")}`);
   let step = 1;
-  console.log(`  ${step++}. Restart Claude Code`);
+  const selectedLabels = config.harnesses.filter((k) => k !== "other").map((k) => HARNESSES.find((h) => h.key === k)?.label).filter(Boolean);
+  console.log(`  ${step++}. Restart your agent sessions${selectedLabels.length ? ` (${selectedLabels.join(", ")})` : ""}`);
   if (config.deployDashboard) {
     console.log(`  ${step++}. Start the dashboard: cd ${config.airchatDir} && docker compose up -d --build`);
   }
   if (config.slackBotToken) {
-    console.log(`  ${step++}. Start the Slack bridge: node ${path2.join(config.airchatDir, "packages", "slack-bridge", "dist", "index.js")}`);
+    console.log(`  ${step++}. Start the Slack bridge: node ${path4.join(config.airchatDir, "packages", "slack-bridge", "dist", "index.js")}`);
     console.log(`     ${dim("Or: cd " + config.airchatDir + " && npx tsx packages/slack-bridge/src/index.ts")}`);
   }
   console.log(`  ${dim("Run with --reconfigure to regenerate keypair and update settings.")}`);
   console.log("");
 }
 var CLI_COMMANDS = /* @__PURE__ */ new Set([
+  // 'dm' ships from fix/mention-hook-delivery; listed here so the published
+  // bin routes it to the CLI once that branch merges.
   "doctor",
   "check",
   "read",
@@ -4890,13 +5520,18 @@ var CLI_COMMANDS = /* @__PURE__ */ new Set([
   "search",
   "status",
   "channels",
+  "agents",
+  "tasks",
+  "dm",
   "notes",
   "note",
   "write-note",
   "backlinks",
   "summarize",
   "gossip",
-  "peer"
+  "peer",
+  "dm",
+  "whoami"
 ]);
 var sub = process.argv[2];
 if (sub && CLI_COMMANDS.has(sub)) {