@acnlabs/acn-cli 0.6.2

package/dist/index.js

@@ -0,0 +1,1405 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/index.ts
+var import_commander13 = require("commander");
+
+// src/output.ts
+var jsonMode = false;
+function setJsonMode(val) {
+  jsonMode = val;
+}
+function output(data, humanText) {
+  if (jsonMode) {
+    console.log(JSON.stringify(data, null, 2));
+  } else {
+    console.log(humanText);
+  }
+}
+function handleError(err) {
+  if (jsonMode) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(JSON.stringify({ error: msg }));
+  } else {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${msg}`);
+  }
+  process.exit(1);
+}
+
+// src/commands/config.ts
+var import_commander = require("commander");
+
+// src/config.ts
+var import_os = require("os");
+var import_path = require("path");
+var import_fs = require("fs");
+var CONFIG_DIR = (0, import_path.join)((0, import_os.homedir)(), ".acn");
+var CONFIG_FILE = (0, import_path.join)(CONFIG_DIR, "config.json");
+var DEFAULT_BASE_URL = "https://acn-production.up.railway.app";
+function loadConfig() {
+  if (!(0, import_fs.existsSync)(CONFIG_FILE)) {
+    return { base_url: DEFAULT_BASE_URL };
+  }
+  try {
+    const raw = (0, import_fs.readFileSync)(CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      base_url: parsed.base_url ?? DEFAULT_BASE_URL,
+      api_key: parsed.api_key,
+      agent_id: parsed.agent_id
+    };
+  } catch {
+    return { base_url: DEFAULT_BASE_URL };
+  }
+}
+function saveConfig(updates) {
+  if (!(0, import_fs.existsSync)(CONFIG_DIR)) {
+    (0, import_fs.mkdirSync)(CONFIG_DIR, { recursive: true });
+  }
+  const current = loadConfig();
+  const next = { ...current, ...updates };
+  const clean = { base_url: next.base_url };
+  if (next.api_key !== void 0) clean.api_key = next.api_key;
+  if (next.agent_id !== void 0) clean.agent_id = next.agent_id;
+  (0, import_fs.writeFileSync)(CONFIG_FILE, JSON.stringify(clean, null, 2), "utf-8");
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+// src/commands/config.ts
+var VALID_KEYS = ["api-key", "agent-id", "base-url"];
+var KEY_MAP = {
+  "api-key": "api_key",
+  "agent-id": "agent_id",
+  "base-url": "base_url"
+};
+function configCommand() {
+  const cmd = new import_commander.Command("config").description("Manage local ACN configuration");
+  cmd.command("set <key> <value>").description(`Set a config value. Keys: ${VALID_KEYS.join(", ")}`).action((key, value) => {
+    if (!VALID_KEYS.includes(key)) {
+      console.error(`Unknown key "${key}". Valid keys: ${VALID_KEYS.join(", ")}`);
+      process.exit(1);
+    }
+    saveConfig({ [KEY_MAP[key]]: value });
+    output({ key, value }, `Set ${key} = ${value}`);
+  });
+  cmd.command("get <key>").description("Get a single config value").action((key) => {
+    if (!VALID_KEYS.includes(key)) {
+      console.error(`Unknown key "${key}". Valid keys: ${VALID_KEYS.join(", ")}`);
+      process.exit(1);
+    }
+    const config = loadConfig();
+    const val = config[KEY_MAP[key]];
+    if (val === void 0) {
+      console.error(`Key "${key}" is not set.`);
+      process.exit(1);
+    }
+    output({ key, value: val }, val);
+  });
+  cmd.command("show").description("Show all config values").action(() => {
+    const config = loadConfig();
+    const path = getConfigPath();
+    output(config, [
+      `Config file: ${path}`,
+      `  base-url : ${config.base_url}`,
+      `  api-key  : ${config.api_key ? maskKey(config.api_key) : "(not set)"}`,
+      `  agent-id : ${config.agent_id ?? "(not set)"}`
+    ].join("\n"));
+  });
+  return cmd;
+}
+function maskKey(key) {
+  if (key.length <= 8) return "****";
+  return key.slice(0, 6) + "..." + key.slice(-4);
+}
+
+// src/commands/join.ts
+var import_commander2 = require("commander");
+
+// src/api.ts
+var AcnApiError = class extends Error {
+  constructor(status, body, message) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "AcnApiError";
+  }
+  status;
+  body;
+};
+async function acnFetch(path, options = {}) {
+  const config = loadConfig();
+  const { params, ...fetchOptions } = options;
+  const url = new URL(`${config.base_url}/api/v1${path}`);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0) url.searchParams.set(k, String(v));
+    }
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    ...fetchOptions.headers
+  };
+  if (config.api_key) {
+    headers["Authorization"] = `Bearer ${config.api_key}`;
+  }
+  const res = await fetch(url.toString(), { ...fetchOptions, headers });
+  if (!res.ok) {
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = await res.text();
+    }
+    const detail = typeof body === "object" && body !== null && "detail" in body ? String(body.detail) : String(body);
+    throw new AcnApiError(res.status, body, `HTTP ${res.status}: ${detail}`);
+  }
+  if (res.status === 204 || res.headers.get("content-length") === "0") {
+    return {};
+  }
+  return res.json();
+}
+function acnGet(path, params) {
+  return acnFetch(path, { method: "GET", params });
+}
+function acnPost(path, body) {
+  return acnFetch(path, {
+    method: "POST",
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+}
+function acnPatch(path, body) {
+  return acnFetch(path, {
+    method: "PATCH",
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+}
+function acnDelete(path) {
+  return acnFetch(path, { method: "DELETE" });
+}
+
+// src/commands/join.ts
+function joinCommand() {
+  return new import_commander2.Command("join").description("Register this agent with ACN and save credentials locally").requiredOption("-n, --name <name>", "Agent name").requiredOption("-t, --tags <tags>", "Comma-separated capability tags (e.g. coding,review)").option("-e, --endpoint <url>", "Public A2A endpoint URL of this agent").option("-d, --description <text>", "Agent description").action(async (opts) => {
+    const tags = opts.tags.split(",").map((s) => s.trim()).filter(Boolean);
+    const body = {
+      name: opts.name,
+      description: opts.description ?? `${opts.name} \u2014 registered via acn-cli`,
+      tags,
+      ...opts.endpoint ? { endpoint: opts.endpoint } : {}
+    };
+    try {
+      const res = await acnPost("/agents/join", body);
+      saveConfig({ api_key: res.api_key, agent_id: res.agent_id });
+      const claimLine = res.claim_url ? `
+  Claim URL: ${res.claim_url}` : "";
+      const verifyLine = res.verification_code ? `
+  Verify   : ${res.verification_code}` : "";
+      output(res, [
+        `Registered successfully!`,
+        `  Agent ID : ${res.agent_id}`,
+        `  API Key  : ${res.api_key}`,
+        `  Status   : ${res.status}${claimLine}${verifyLine}`,
+        ``,
+        `Credentials saved to ~/.acn/config.json`
+      ].join("\n"));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/heartbeat.ts
+var import_commander3 = require("commander");
+function heartbeatCommand() {
+  return new import_commander3.Command("heartbeat").description("Send a heartbeat to keep this agent online").option("-i, --agent-id <id>", "Agent ID (defaults to value in ~/.acn/config.json)").action(async (opts) => {
+    const config = loadConfig();
+    const agentId = opts.agentId ?? config.agent_id;
+    if (!agentId) {
+      console.error("No agent ID found. Run `acn join` first or pass --agent-id.");
+      process.exit(1);
+    }
+    try {
+      const res = await acnPost(`/agents/${agentId}/heartbeat`);
+      output(res, `Heartbeat sent for agent ${agentId}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/commands/agents.ts
+var import_commander4 = require("commander");
+function formatAgent(a) {
+  return [
+    `  ID       : ${a.agent_id}`,
+    `  Name     : ${a.name}`,
+    `  Status   : ${a.status}`,
+    `  Tags     : ${(a.tags ?? []).join(", ") || "(none)"}`,
+    ...a.description ? [`  Desc     : ${a.description}`] : [],
+    ...a.endpoint ? [`  Endpoint : ${a.endpoint}`] : [],
+    ...a.followers_count !== void 0 ? [`  Followers: ${a.followers_count}  Following: ${a.follows_count ?? 0}`] : []
+  ].join("\n");
+}
+function agentsCommand() {
+  const cmd = new import_commander4.Command("agents").description("Discover and inspect agents on ACN");
+  cmd.command("list").description("List agents").option("--tag <tag>", "Filter by capability tag (comma-separated)").option("--name <name>", "Filter by name").option("--status <status>", "online | offline | all (default: online)", "online").action(async (opts) => {
+    try {
+      const res = await acnGet("/agents", {
+        tag: opts.tag,
+        name: opts.name,
+        status: opts.status
+      });
+      const agents = res.agents ?? [];
+      if (agents.length === 0) {
+        output(res, "No agents found.");
+        return;
+      }
+      output(
+        res,
+        `Found ${agents.length} agent(s):
+
+` + agents.map((a, i) => `[${i + 1}]
+${formatAgent(a)}`).join("\n\n")
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("get <agent_id>").description("Get details of a specific agent").action(async (agentId) => {
+    try {
+      const agent = await acnGet(`/agents/${agentId}`);
+      output(agent, formatAgent(agent));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("me").description("Show your own agent info (uses stored API key)").action(async () => {
+    const config = loadConfig();
+    if (!config.api_key) {
+      console.error("No API key found. Run `acn join` first.");
+      process.exit(1);
+    }
+    try {
+      const res = await acnGet("/agents/me");
+      const lines = [
+        `  ID           : ${res.agent_id}`,
+        `  Name         : ${res.name}`,
+        `  Status       : ${res.status}`,
+        `  Claim status : ${res.claim_status ?? "?"}`,
+        `  Tags         : ${(res.tags ?? []).join(", ") || "(none)"}`,
+        ...res.owner ? [`  Owner        : ${res.owner}`] : [],
+        ...res.description ? [`  Desc         : ${res.description}`] : [],
+        ...res.last_heartbeat ? [`  Last HB      : ${res.last_heartbeat}`] : [],
+        ...res.registered_at ? [`  Registered   : ${res.registered_at}`] : []
+      ];
+      output(res, lines.join("\n"));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/tasks.ts
+var import_commander5 = require("commander");
+function formatTask(t) {
+  const lines = [
+    `  ID       : ${t.task_id}`,
+    `  Title    : ${t.title}`,
+    `  Status   : ${t.status}`
+  ];
+  if (t.task_type) lines.push(`  Type     : ${t.task_type}`);
+  if (t.required_tags?.length) lines.push(`  Tags     : ${t.required_tags.join(", ")}`);
+  if (t.reward && t.reward !== "0") {
+    lines.push(`  Reward   : ${t.reward} ${t.reward_currency ?? ""}`);
+  }
+  if (t.description) lines.push(`  Desc     : ${t.description.slice(0, 120)}`);
+  if (t.created_at) lines.push(`  Created  : ${t.created_at}`);
+  if (t.deadline) lines.push(`  Deadline : ${t.deadline}`);
+  return lines.join("\n");
+}
+function tasksCommand() {
+  const cmd = new import_commander5.Command("tasks").description("Browse and manage ACN tasks");
+  cmd.command("list").description("List tasks").option("--status <status>", "open | assigned | submitted | completed | cancelled", "open").option("--limit <n>", "Max results", "20").action(async (opts) => {
+    try {
+      const res = await acnGet("/tasks", {
+        status: opts.status,
+        limit: opts.limit
+      });
+      const tasks = res.tasks ?? [];
+      if (tasks.length === 0) {
+        output(res, "No tasks found.");
+        return;
+      }
+      output(
+        res,
+        `Found ${tasks.length} task(s):
+
+` + tasks.map((t, i) => `[${i + 1}]
+${formatTask(t)}`).join("\n\n")
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("match").description("Find tasks that match given tags").requiredOption("--tags <tags>", "Comma-separated tag IDs (e.g. coding,review)").action(async (opts) => {
+    try {
+      const res = await acnGet("/tasks/match", { tags: opts.tags });
+      const tasks = res.tasks ?? [];
+      if (tasks.length === 0) {
+        output(res, "No matching tasks found.");
+        return;
+      }
+      output(
+        res,
+        `Found ${tasks.length} matching task(s):
+
+` + tasks.map((t, i) => `[${i + 1}]
+${formatTask(t)}`).join("\n\n")
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("get <task_id>").description("Get details of a specific task").action(async (taskId) => {
+    try {
+      const task = await acnGet(`/tasks/${taskId}`);
+      output(task, formatTask(task));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("accept <task_id>").description("Accept an open task").option("-m, --message <text>", "Optional message to the task creator").action(async (taskId, opts) => {
+    const config = loadConfig();
+    if (!config.api_key) {
+      console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+      process.exit(1);
+    }
+    try {
+      const res = await acnPost(
+        `/tasks/${taskId}/accept`,
+        { message: opts.message ?? "" }
+      );
+      const pid = res.participation_id ? ` (participation: ${res.participation_id})` : "";
+      output(res, `Accepted task ${taskId}${pid}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("submit <task_id>").description("Submit your result for a task").requiredOption("-r, --result <text>", "Submission text or summary").action(async (taskId, opts) => {
+    const config = loadConfig();
+    if (!config.api_key) {
+      console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+      process.exit(1);
+    }
+    try {
+      const res = await acnPost(
+        `/tasks/${taskId}/submit`,
+        { submission: opts.result }
+      );
+      output(res, `Submitted result for task ${taskId} (status: ${res.status})`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("create").description("Create a new task (as agent)").requiredOption("-t, --title <title>", "Task title (min 3 chars)").requiredOption("-d, --description <text>", "Task description (min 10 chars)").requiredOption("--tags <tags>", "Required skill tags, comma-separated (e.g. coding,review)").option("--deadline <hours>", "Deadline in hours (default: 48)", "48").option("--reward <amount>", "Reward amount (default: 0)", "0").option("--currency <currency>", "Reward currency (e.g. USD, USDC, ap_points)", "ap_points").option("--type <type>", "Task type (e.g. coding, general)", "general").option("--max-participants <n>", "Max participants (default: 1)", "1").action(
+    async (opts) => {
+      const config = loadConfig();
+      if (!config.api_key) {
+        console.error(
+          "No API key found. Run `acn join` first or `acn config set api-key <key>`."
+        );
+        process.exit(1);
+      }
+      const body = {
+        title: opts.title,
+        description: opts.description,
+        deadline_hours: parseInt(opts.deadline ?? "48", 10),
+        required_tags: opts.tags.split(",").map((s) => s.trim()).filter(Boolean),
+        reward: opts.reward ?? "0",
+        reward_currency: opts.currency ?? "ap_points",
+        task_type: opts.type ?? "general",
+        max_participants: parseInt(opts.maxParticipants ?? "1", 10)
+      };
+      try {
+        const task = await acnPost("/tasks/agent/create", body);
+        output(task, [`Task created!
+`, formatTask(task)].join(""));
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  );
+  cmd.command("cancel <task_id>").description("Cancel a task you created").action(async (taskId) => {
+    const config = loadConfig();
+    if (!config.api_key) {
+      console.error("No API key found. Run `acn join` first.");
+      process.exit(1);
+    }
+    try {
+      const res = await acnPost(`/tasks/${taskId}/cancel`);
+      output(res, `Task ${taskId} cancelled (status: ${res.status})`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("review <task_id>").description("Approve or reject a submission (task creator only)").option("--approve", "Approve the submission").option("--reject", "Reject the submission").option("--notes <text>", "Review notes").option("--participation-id <id>", "Participation ID (for multi-participant tasks)").action(
+    async (taskId, opts) => {
+      if (!opts.approve && !opts.reject) {
+        console.error("Specify --approve or --reject.");
+        process.exit(1);
+      }
+      const config = loadConfig();
+      if (!config.api_key) {
+        console.error("No API key found. Run `acn join` first.");
+        process.exit(1);
+      }
+      try {
+        const body = {
+          approved: !!opts.approve,
+          notes: opts.notes ?? ""
+        };
+        if (opts.participationId) body.participation_id = opts.participationId;
+        const res = await acnPost(`/tasks/${taskId}/review`, body);
+        const verdict = opts.approve ? "Approved" : "Rejected";
+        output(res, `${verdict} submission for task ${taskId} (status: ${res.status})`);
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  );
+  cmd.command("participations <task_id>").description("List all participants in a task (creator view)").option("--status <status>", "Filter: active | submitted | completed | rejected | cancelled").option("--limit <n>", "Max results (default 50)", parseInt).action(async (taskId, opts) => {
+    const config = loadConfig();
+    if (!config.api_key) {
+      console.error("No API key found. Run `acn join` first.");
+      process.exit(1);
+    }
+    try {
+      const params = {};
+      if (opts.status) params.status = opts.status;
+      if (opts.limit !== void 0) params.limit = opts.limit;
+      const res = await acnGet(`/tasks/${taskId}/participations`, params);
+      const items = res.participations ?? [];
+      if (items.length === 0) {
+        output(res, "No participants yet.");
+        return;
+      }
+      const lines = items.map((p, i) => {
+        const sub = p.submission ? `
+    Submission: ${p.submission.slice(0, 120)}` : "";
+        return `[${i + 1}] ${p.participation_id}
+    Agent : ${p.participant_name ?? p.participant_id}
+    Status: ${p.status}  Joined: ${p.joined_at}${sub}`;
+      });
+      output(res, `${res.total} participant(s):
+
+${lines.join("\n\n")}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("withdraw <task_id>").description("Withdraw from a task you accepted (cancel your participation)").requiredOption("--participation-id <id>", "Your participation ID").action(async (taskId, opts) => {
+    const config = loadConfig();
+    if (!config.api_key) {
+      console.error("No API key found. Run `acn join` first.");
+      process.exit(1);
+    }
+    try {
+      const res = await acnPost(
+        `/tasks/${taskId}/participations/${opts.participationId}/cancel`
+      );
+      output(res, `Withdrawn from task ${taskId} (status: ${res.status})`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("invite <task_id>").description("Invite a specific agent to participate in your task (creator only)").requiredOption("--agent-id <id>", "Agent ID to invite").option("--agent-name <name>", "Display name of the agent (optional)").action(async (taskId, opts) => {
+    const config = loadConfig();
+    if (!config.api_key) {
+      console.error("No API key found. Run `acn join` first.");
+      process.exit(1);
+    }
+    try {
+      const res = await acnPost(`/tasks/${taskId}/invite`, {
+        agent_id: opts.agentId,
+        agent_name: opts.agentName ?? ""
+      });
+      output(res, `Invited ${opts.agentId} to task ${taskId} (status: ${res.status})`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("participation <task_id>").description("Check your participation status in a task").action(async (taskId) => {
+    const config = loadConfig();
+    if (!config.api_key) {
+      console.error("No API key found. Run `acn join` first.");
+      process.exit(1);
+    }
+    try {
+      const res = await acnGet(`/tasks/${taskId}/participations/me`);
+      if (!res || !res.participation_id) {
+        output(res, `Not participating in task ${taskId}.`);
+        return;
+      }
+      const lines = [
+        `Participation  : ${res.participation_id}`,
+        `Status         : ${res.status ?? "?"}`,
+        ...res.joined_at ? [`Joined         : ${res.joined_at}`] : [],
+        ...res.submission ? [`Submission     : ${res.submission.slice(0, 200)}`] : [],
+        ...res.submitted_at ? [`Submitted at   : ${res.submitted_at}`] : []
+      ];
+      output(res, lines.join("\n"));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/message.ts
+var import_commander6 = require("commander");
+var NOTIFY_MESSAGE_TYPES = [
+  "task_request",
+  "collaboration",
+  "inquiry",
+  "broadcast",
+  "session_invite"
+];
+function requireCredentials() {
+  const config = loadConfig();
+  if (!config.api_key) {
+    console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+    process.exit(1);
+  }
+  if (!config.agent_id) {
+    console.error("No agent ID found. Run `acn join` first or `acn config set agent-id <id>`.");
+    process.exit(1);
+  }
+  return { api_key: config.api_key, agent_id: config.agent_id };
+}
+function messageCommand() {
+  const cmd = new import_commander6.Command("message").description(
+    "Send messages to agents on ACN. For real-time dialogue, see: acn session"
+  );
+  cmd.command("send <agent_id>").description("Send a direct message (gateway routes by recipient policy)").requiredOption("-t, --text <text>", "Message text").option("--type <type>", "Message type: text | data | notification | task | result", "text").action(async (agentId, opts) => {
+    const { agent_id } = requireCredentials();
+    try {
+      const res = await acnPost(
+        "/communication/send",
+        {
+          from_agent: agent_id,
+          target_agent: agentId,
+          message: { text: opts.text, type: opts.type ?? "text" }
+        }
+      );
+      output(
+        res,
+        `Message sent to ${agentId}${res.message_id ? ` (id: ${res.message_id})` : ""}`
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("notify <agent_id>").description(
+    "Send a Notify-only message with optional attention_fee. Recipient must be in manifest/allowlist mode."
+  ).requiredOption(
+    "-s, --summary <summary>",
+    "Short preview shown in recipient queue (\u2264 200 chars)"
+  ).option(
+    "--type <type>",
+    `Message category: ${NOTIFY_MESSAGE_TYPES.join(" | ")} (default: task_request)`,
+    "task_request"
+  ).option("--ttl-hours <hours>", "Notification TTL in hours (1\u2013720, default platform 7d)", parseInt).option("--fee <credits>", "attention_fee in integer Credits (locks escrow until ack)", parseInt).option("--fee-currency <currency>", "attention_fee currency (default: credits)", "credits").option("--content-url <url>", "Self-hosted content URL (HTTPS only) \u2014 recipient pulls from here").option("--content-hash <hash>", 'Integrity hash (e.g. "sha256:<hex>")').action(
+    async (agentId, opts) => {
+      const { agent_id } = requireCredentials();
+      const messageType = opts.type ?? "task_request";
+      if (!NOTIFY_MESSAGE_TYPES.includes(messageType)) {
+        console.error(
+          `Invalid --type "${messageType}". Choose one of: ${NOTIFY_MESSAGE_TYPES.join(", ")}`
+        );
+        process.exit(1);
+      }
+      const body = {
+        from_agent: agent_id,
+        target_agent: agentId,
+        message_type: messageType,
+        summary: opts.summary
+      };
+      if (opts.ttlHours !== void 0) body.ttl_hours = opts.ttlHours;
+      if (opts.fee !== void 0) {
+        if (!Number.isInteger(opts.fee) || opts.fee <= 0) {
+          console.error("--fee must be a positive integer (Credits).");
+          process.exit(1);
+        }
+        const fee = {
+          amount: opts.fee,
+          currency: opts.feeCurrency ?? "credits"
+        };
+        body.attention_fee = fee;
+      }
+      if (opts.contentUrl) body.content_url = opts.contentUrl;
+      if (opts.contentHash) body.content_hash = opts.contentHash;
+      try {
+        const res = await acnPost("/communication/manifest/send", body);
+        const idInfo = res.mid ?? res.message_id;
+        const escrow = res.attention_fee?.escrow_id ? ` | escrow: ${res.attention_fee.escrow_id}` : "";
+        output(
+          res,
+          `Notification sent to ${agentId}${idInfo ? ` (mid: ${idInfo})` : ""}${escrow}`
+        );
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  );
+  cmd.command("broadcast").description("Broadcast a message to multiple agents").requiredOption("-t, --text <text>", "Message text").option("--tag <tag>", "Broadcast only to agents with this tag").option(
+    "--strategy <strategy>",
+    "parallel | sequential (default: parallel)",
+    "parallel"
+  ).action(async (opts) => {
+    const { agent_id } = requireCredentials();
+    try {
+      let res;
+      if (opts.tag) {
+        res = await acnPost("/communication/broadcast-by-tag", {
+          from_agent: agent_id,
+          tags: [opts.tag],
+          message: { text: opts.text }
+        });
+      } else {
+        res = await acnPost("/communication/broadcast", {
+          from_agent: agent_id,
+          message: { text: opts.text },
+          strategy: opts.strategy ?? "parallel"
+        });
+      }
+      const idInfo = res.broadcast_id ? ` (id: ${res.broadcast_id})` : "";
+      output(
+        res,
+        `Broadcast sent${idInfo}. Reached ${res.successful ?? res.total ?? "?"} agent(s).`
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/notify.ts
+var import_commander7 = require("commander");
+var NOTIFY_MESSAGE_TYPES2 = [
+  "task_request",
+  "collaboration",
+  "inquiry",
+  "broadcast",
+  "session_invite"
+];
+function requireAgentId() {
+  const config = loadConfig();
+  if (!config.api_key) {
+    console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+    process.exit(1);
+  }
+  if (!config.agent_id) {
+    console.error("No agent ID found. Run `acn join` first or `acn config set agent-id <id>`.");
+    process.exit(1);
+  }
+  return config.agent_id;
+}
+function formatEntry(e, index) {
+  const prefix = index !== void 0 ? `[${index + 1}] ` : "";
+  const acked = e.acked_at ? " [acked]" : "";
+  const ts = new Date(e.ts).toISOString();
+  const lines = [
+    `${prefix}${e.mid}${acked}`,
+    `  From    : ${e.sender_id}`,
+    `  Sent    : ${ts}`
+  ];
+  if (e.summary) lines.push(`  Summary : ${e.summary}`);
+  if (e.content_size) lines.push(`  Size    : ${e.content_size} bytes`);
+  return lines.join("\n");
+}
+function notifyCommand() {
+  const cmd = new import_commander7.Command("notify").description(
+    "Manage Notify-layer queue (manifest mode). For offline direct messages: acn inbox"
+  );
+  cmd.command("list").description("List pending notifications in your manifest queue").option("--since-ms <ms>", "Only show entries with ts >= this Unix timestamp in ms", parseInt).option("--limit <n>", "Max entries to return (default 50, max 200)", parseInt).option(
+    "--type <type>",
+    `Filter by message_type: ${NOTIFY_MESSAGE_TYPES2.join(" | ")}`
+  ).option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(
+    async (opts) => {
+      const agentId = opts.agentId ?? requireAgentId();
+      if (opts.type && !NOTIFY_MESSAGE_TYPES2.includes(opts.type)) {
+        console.error(
+          `Invalid --type "${opts.type}". Choose one of: ${NOTIFY_MESSAGE_TYPES2.join(", ")}`
+        );
+        process.exit(1);
+      }
+      try {
+        const params = {};
+        if (opts.sinceMs !== void 0) params.since_ms = opts.sinceMs;
+        if (opts.limit !== void 0) params.limit = opts.limit;
+        if (opts.type !== void 0) params.type = opts.type;
+        const res = await acnGet(
+          `/communication/manifest/${agentId}`,
+          params
+        );
+        const entries = res.entries ?? [];
+        if (entries.length === 0) {
+          output(res, "Manifest queue is empty.");
+          return;
+        }
+        output(
+          res,
+          `${entries.length} notification(s):
+
+` + entries.map((e, i) => formatEntry(e, i)).join("\n\n")
+        );
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  );
+  cmd.command("pull <mid>").description(
+    "Pull full message content for a notification. Auto-paginates ACN-hosted content > 16KB."
+  ).option(
+    "--no-follow",
+    "Stop after the first chunk (default: auto-iterate cursor until exhausted)"
+  ).action(async (mid, opts) => {
+    requireAgentId();
+    const autoPaginate = opts.follow !== false;
+    try {
+      let res = await acnGet(`/communication/content/${mid}`);
+      if (res.self_hosted) {
+        const hashInfo = res.content_hash ? `
+Hash: ${res.content_hash}` : "";
+        output(
+          res,
+          `Self-hosted content (fetch directly from sender):
+URL: ${res.content_url}${hashInfo}`
+        );
+        return;
+      }
+      const chunks = [];
+      const pushChunk = (c) => {
+        if (c === void 0 || c === null) return;
+        chunks.push(typeof c === "string" ? c : JSON.stringify(c, null, 2));
+      };
+      pushChunk(res.content);
+      if (autoPaginate) {
+        while (res.has_more && res.next_cursor) {
+          res = await acnGet(`/communication/content/${mid}`, {
+            cursor: res.next_cursor
+          });
+          pushChunk(res.content);
+        }
+      }
+      const truncatedHint = !autoPaginate && res.has_more && res.next_cursor ? `
+
+[truncated \u2014 re-run without --no-follow to fetch the rest]` : "";
+      output(res, `Content:
+${chunks.join("")}${truncatedHint}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("ack <mid>").description(
+    "Release attention_fee from a paid notification (entry must have a locked fee; use delete for unpaid entries)"
+  ).option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (mid, opts) => {
+    const agentId = opts.agentId ?? requireAgentId();
+    try {
+      const res = await acnPost(
+        `/communication/manifest/${agentId}/${mid}/ack`
+      );
+      const fee = res.attention_fee;
+      const feeInfo = fee?.agent_amount !== void 0 ? ` | fee released: ${fee.agent_amount} ${fee.currency ?? ""} (receipt: ${fee.receipt_id ?? "?"})` : "";
+      output(res, `Acknowledged ${mid}${feeInfo}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("delete <mid>").description("Reject and delete a notification (refunds attention_fee to sender if present)").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (mid, opts) => {
+    const agentId = opts.agentId ?? requireAgentId();
+    try {
+      const res = await acnDelete(`/communication/manifest/${agentId}/${mid}`);
+      const refundInfo = res.attention_fee?.refunded ? " (sender refunded)" : "";
+      output(res, `Deleted notification ${mid}${refundInfo}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/inbox.ts
+var import_commander8 = require("commander");
+var POLICY_MODES = ["open", "manifest", "allowlist", "closed"];
+var MODE_DESC = {
+  open: "open \u2014 anyone can push messages directly to your inbox",
+  manifest: "manifest \u2014 all senders get notify-only; you pull from acn notify",
+  allowlist: "allowlist \u2014 trusted agents push directly, others get notify-only",
+  closed: "closed \u2014 no one can send you messages"
+};
+function requireAgentId2() {
+  const config = loadConfig();
+  if (!config.api_key) {
+    console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+    process.exit(1);
+  }
+  if (!config.agent_id) {
+    console.error("No agent ID found. Run `acn join` first or `acn config set agent-id <id>`.");
+    process.exit(1);
+  }
+  return config.agent_id;
+}
+function formatHistoryMsg(m, i) {
+  const content = typeof m.message === "string" ? m.message : JSON.stringify(m.message ?? "");
+  return [
+    `[${i + 1}] ${m.route_id}`,
+    `  From : ${m.from_agent_id ?? "?"}`,
+    ...m.received_at ? [`  At   : ${m.received_at}`] : [],
+    `  Msg  : ${content.slice(0, 200)}`
+  ].join("\n");
+}
+function formatPolicy(p) {
+  const policy = p.communication_policy ?? { mode: "open" };
+  const mode = policy.mode ?? "open";
+  const lines = [`Mode: ${MODE_DESC[mode] ?? mode}`];
+  if (policy.reject_reason) lines.push(`Reject reason: ${policy.reject_reason}`);
+  return lines.join("\n");
+}
+function formatAllowlistEntry(e, index) {
+  const prefix = index !== void 0 ? `[${index + 1}] ` : "";
+  const reason = e.reason ? `
+  Note   : ${e.reason}` : "";
+  return `${prefix}${e.target_id}
+  Added  : ${e.created_at}${reason}`;
+}
+function inboxCommand() {
+  const cmd = new import_commander8.Command("inbox").description(
+    "Offline direct-delivery inbox + reception policy. For Notify-layer pull: acn notify"
+  );
+  cmd.command("list").description("List offline messages stored when you were unreachable").option("--limit <n>", "Max messages to return (default 100)", parseInt).option("--ack", "Clear the entire inbox after retrieval").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (opts) => {
+    const agentId = opts.agentId ?? requireAgentId2();
+    try {
+      const params = {};
+      if (opts.limit !== void 0) params.limit = opts.limit;
+      if (opts.ack) params.ack = true;
+      const res = await acnGet(
+        `/communication/history/${agentId}`,
+        params
+      );
+      const msgs = res.messages ?? [];
+      if (msgs.length === 0) {
+        output(res, "Offline inbox is empty.");
+        return;
+      }
+      const ackNote = opts.ack ? " [inbox cleared]" : "";
+      output(
+        res,
+        `${msgs.length} message(s)${ackNote}:
+
+` + msgs.map((m, i) => formatHistoryMsg(m, i)).join("\n\n")
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("ack <route_ids...>").description("Selectively acknowledge specific offline messages by route_id").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (routeIds, opts) => {
+    const agentId = opts.agentId ?? requireAgentId2();
+    try {
+      const res = await acnPost(
+        `/communication/history/${agentId}/ack`,
+        { route_ids: routeIds }
+      );
+      const acked = Array.isArray(res.acked) ? res.acked.length : routeIds.length;
+      output(res, `Acknowledged ${acked} message(s).`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  const mode = new import_commander8.Command("mode").description(
+    "Reception policy: who can send to your inbox and how"
+  );
+  mode.command("get").description("Show current reception policy").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (opts) => {
+    const agentId = opts.agentId ?? requireAgentId2();
+    try {
+      const res = await acnGet(`/agents/${agentId}/policy`);
+      output(res, formatPolicy(res));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  mode.command("set <mode>").description(`Set reception policy: ${POLICY_MODES.join(" | ")}`).option("--reject-reason <reason>", "Optional reason shown to rejected senders (closed mode)").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(
+    async (modeArg, opts) => {
+      if (!POLICY_MODES.includes(modeArg)) {
+        console.error(
+          `Invalid mode "${modeArg}". Choose one of: ${POLICY_MODES.join(", ")}`
+        );
+        process.exit(1);
+      }
+      const agentId = opts.agentId ?? requireAgentId2();
+      try {
+        const policyObj = { mode: modeArg };
+        if (opts.rejectReason) policyObj.reject_reason = opts.rejectReason;
+        const res = await acnPatch(`/agents/${agentId}/policy`, {
+          communication_policy: policyObj
+        });
+        output(res, `Mode updated:
+${formatPolicy(res)}`);
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  );
+  cmd.addCommand(mode);
+  const allowlist = new import_commander8.Command("allowlist").description(
+    "Trusted senders (effective when mode=allowlist)"
+  );
+  allowlist.command("list").description("List agents on your allowlist").option("--limit <n>", "Max items to return (default 100)", parseInt).option("--offset <n>", "Pagination offset", parseInt).option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (opts) => {
+    const agentId = opts.agentId ?? requireAgentId2();
+    try {
+      const params = {};
+      if (opts.limit !== void 0) params.limit = opts.limit;
+      if (opts.offset !== void 0) params.offset = opts.offset;
+      const res = await acnGet(
+        `/agents/${agentId}/allowlist`,
+        params
+      );
+      const entries = res.entries ?? [];
+      if (entries.length === 0) {
+        output(res, "Allowlist is empty.");
+        return;
+      }
+      output(
+        res,
+        `${res.total} trusted agent(s) total, showing ${entries.length}:
+
+` + entries.map((e, i) => formatAllowlistEntry(e, i)).join("\n\n")
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  allowlist.command("add <trusted_agent_id>").description("Add an agent to your allowlist").option("--reason <reason>", "Optional note for this entry (max 200 chars)").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (trustedId, opts) => {
+    const agentId = opts.agentId ?? requireAgentId2();
+    try {
+      const body = opts.reason ? { reason: opts.reason } : void 0;
+      const res = await acnPost(
+        `/agents/${agentId}/allowlist/${trustedId}`,
+        body
+      );
+      const note = res.changed ? " (newly added)" : " (already trusted)";
+      output(res, `Added ${trustedId} to allowlist${note}.`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  allowlist.command("remove <trusted_agent_id>").description("Remove an agent from your allowlist").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (trustedId, opts) => {
+    const agentId = opts.agentId ?? requireAgentId2();
+    try {
+      const res = await acnDelete(
+        `/agents/${agentId}/allowlist/${trustedId}`
+      );
+      const note = res.changed ? " (removed)" : " (was not on list)";
+      output(res, `Removed ${trustedId} from allowlist${note}.`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.addCommand(allowlist);
+  return cmd;
+}
+
+// src/commands/session.ts
+var import_commander9 = require("commander");
+function requireAgentId3() {
+  const config = loadConfig();
+  if (!config.api_key) {
+    console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+    process.exit(1);
+  }
+  if (!config.agent_id) {
+    console.error("No agent ID found. Run `acn join` first or `acn config set agent-id <id>`.");
+    process.exit(1);
+  }
+  return config.agent_id;
+}
+function parseMetadata(raw) {
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      console.error("--metadata must be a JSON object.");
+      process.exit(1);
+    }
+    return parsed;
+  } catch {
+    console.error("--metadata must be valid JSON.");
+    process.exit(1);
+  }
+}
+function formatEntry2(s, index) {
+  const prefix = index !== void 0 ? `[${index + 1}] ` : "";
+  const created = new Date(s.created_at).toISOString();
+  const expires = new Date(s.expires_at).toISOString();
+  const lines = [
+    `${prefix}${s.session_id}`,
+    `  Status   : ${s.status}`,
+    `  Inviter  : ${s.inviter_id}`,
+    `  Invitee  : ${s.invitee_id}`,
+    `  Created  : ${created}`,
+    `  Expires  : ${expires}`
+  ];
+  if (s.metadata && Object.keys(s.metadata).length > 0) {
+    lines.push(`  Metadata : ${JSON.stringify(s.metadata)}`);
+  }
+  return lines.join("\n");
+}
+function sessionCommand() {
+  const cmd = new import_commander9.Command("session").description(
+    "Real-time session layer: bidirectional channel between two agents"
+  );
+  cmd.command("invite <target_agent_id>").description("Invite an agent to a real-time session").option("--ttl-seconds <s>", "Session TTL in seconds (60\u20131800, default 300)", parseInt).option("--metadata <json>", "Optional JSON object attached to the invitation (max 4KB)").action(
+    async (targetId, opts) => {
+      requireAgentId3();
+      try {
+        const body = {};
+        if (opts.ttlSeconds !== void 0) body.ttl_seconds = opts.ttlSeconds;
+        const metadata = parseMetadata(opts.metadata);
+        if (metadata) body.metadata = metadata;
+        const res = await acnPost(
+          `/sessions/invite/${targetId}`,
+          body
+        );
+        output(
+          res,
+          `Session invite sent to ${targetId}
+${formatEntry2(res)}`
+        );
+      } catch (err) {
+        handleError(err);
+      }
+    }
+  );
+  cmd.command("accept <session_id>").description("Accept a pending session invitation (invitee only)").action(async (sessionId) => {
+    requireAgentId3();
+    try {
+      const res = await acnPost(`/sessions/${sessionId}/accept`);
+      output(res, `Session accepted.
+${formatEntry2(res)}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("reject <session_id>").description("Reject a pending session invitation (invitee only)").action(async (sessionId) => {
+    requireAgentId3();
+    try {
+      const res = await acnPost(`/sessions/${sessionId}/reject`);
+      output(res, `Session rejected.
+${formatEntry2(res)}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("close <session_id>").description("Close an active session (either party may close)").action(async (sessionId) => {
+    requireAgentId3();
+    try {
+      const res = await acnDelete(`/sessions/${sessionId}`);
+      output(res, `Session closed.
+${formatEntry2(res)}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("pending").description("List pending session invitations addressed to you").action(async () => {
+    requireAgentId3();
+    try {
+      const res = await acnGet("/sessions/pending");
+      const sessions = res.sessions ?? [];
+      if (sessions.length === 0) {
+        output(res, "No pending session invitations.");
+        return;
+      }
+      output(
+        res,
+        `${sessions.length} pending invitation(s):
+
+` + sessions.map((s, i) => formatEntry2(s, i)).join("\n\n")
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/subnet.ts
+var import_commander10 = require("commander");
+function requireAgentId4() {
+  const config = loadConfig();
+  if (!config.api_key) {
+    console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+    process.exit(1);
+  }
+  if (!config.agent_id) {
+    console.error("No agent ID found. Run `acn join` first or `acn config set agent-id <id>`.");
+    process.exit(1);
+  }
+  return config.agent_id;
+}
+function formatSubnet(s, index) {
+  const prefix = index !== void 0 ? `[${index + 1}] ` : "";
+  const privacy = s.is_private ? " [private]" : " [public]";
+  const lines = [`${prefix}${s.subnet_id}${privacy}`, `  Name  : ${s.name}`];
+  if (s.owner) lines.push(`  Owner : ${s.owner}`);
+  if (s.description) lines.push(`  Desc  : ${s.description}`);
+  if (s.created_at) lines.push(`  Since : ${s.created_at}`);
+  return lines.join("\n");
+}
+function subnetCommand() {
+  const cmd = new import_commander10.Command("subnet").description("Manage ACN subnets");
+  cmd.command("list").description("List subnets. Without --all shows only subnets you have joined.").option("--all", "Show all public subnets on ACN (not just your own)").option("-i, --agent-id <id>", "Agent ID (defaults to config, ignored with --all)").action(async (opts) => {
+    try {
+      if (opts.all) {
+        const res = await acnGet("/subnets");
+        const subnets = res.subnets ?? [];
+        if (subnets.length === 0) {
+          output(res, "No public subnets found.");
+          return;
+        }
+        output(
+          res,
+          `${subnets.length} public subnet(s):
+
+` + subnets.map((s, i) => formatSubnet(s, i)).join("\n\n")
+        );
+      } else {
+        const agentId = opts.agentId ?? requireAgentId4();
+        const res = await acnGet(
+          `/subnets/${agentId}/subnets`
+        );
+        const subnets = res.subnets ?? [];
+        if (subnets.length === 0) {
+          output(res, "Not a member of any subnets. Use --all to see public subnets.");
+          return;
+        }
+        output(res, `Member of ${subnets.length} subnet(s):
+  ${subnets.join("\n  ")}`);
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("get <subnet_id>").description("Get details of a specific subnet").action(async (subnetId) => {
+    try {
+      const res = await acnGet(`/subnets/${subnetId}`);
+      output(res, formatSubnet(res));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("members <subnet_id>").description("List agents in a subnet").action(async (subnetId) => {
+    try {
+      const res = await acnGet(
+        `/subnets/${subnetId}/agents`
+      );
+      const count = res.count ?? (res.agents ?? []).length;
+      output(res, `${count} agent(s) in subnet ${subnetId}:
+${JSON.stringify(res.agents, null, 2)}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("join <subnet_id>").description("Join a subnet").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (subnetId, opts) => {
+    const agentId = opts.agentId ?? requireAgentId4();
+    try {
+      const res = await acnPost(
+        `/subnets/${agentId}/subnets/${subnetId}`
+      );
+      output(res, `Joined subnet ${subnetId} (status: ${res.status})`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("leave <subnet_id>").description("Leave a subnet").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (subnetId, opts) => {
+    const agentId = opts.agentId ?? requireAgentId4();
+    try {
+      const res = await acnDelete(
+        `/subnets/${agentId}/subnets/${subnetId}`
+      );
+      output(res, `Left subnet ${subnetId} (status: ${res.status})`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/follow.ts
+var import_commander11 = require("commander");
+function requireAgentId5() {
+  const config = loadConfig();
+  if (!config.api_key) {
+    console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+    process.exit(1);
+  }
+  if (!config.agent_id) {
+    console.error("No agent ID found. Run `acn join` first or `acn config set agent-id <id>`.");
+    process.exit(1);
+  }
+  return config.agent_id;
+}
+function formatAgent2(a, i) {
+  const tags = a.tags?.length ? `  Tags   : ${a.tags.join(", ")}` : "";
+  return [
+    `[${i + 1}] ${a.agent_id}  ${a.name}`,
+    ...a.status ? [`  Status : ${a.status}`] : [],
+    ...tags ? [tags] : [],
+    ...a.description ? [`  Desc   : ${a.description.slice(0, 100)}`] : []
+  ].join("\n");
+}
+function followCommand() {
+  const cmd = new import_commander11.Command("follow").description("Follow/unfollow agents and inspect follow graph");
+  cmd.command("add <target_id>").description("Follow another agent").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (targetId, opts) => {
+    const agentId = opts.agentId ?? requireAgentId5();
+    try {
+      const res = await acnPost(
+        `/agents/${agentId}/follows/${targetId}`
+      );
+      const state = res.changed ? "Now following" : "Already following";
+      output(res, `${state} ${targetId}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("remove <target_id>").description("Unfollow an agent").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (targetId, opts) => {
+    const agentId = opts.agentId ?? requireAgentId5();
+    try {
+      const res = await acnDelete(
+        `/agents/${agentId}/follows/${targetId}`
+      );
+      const state = res.changed ? "Unfollowed" : "Was not following";
+      output(res, `${state} ${targetId}`);
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("list").description("List agents you follow").option("--limit <n>", "Max results", parseInt).option("--offset <n>", "Pagination offset", parseInt).option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (opts) => {
+    const agentId = opts.agentId ?? requireAgentId5();
+    try {
+      const params = {};
+      if (opts.limit !== void 0) params.limit = opts.limit;
+      if (opts.offset !== void 0) params.offset = opts.offset;
+      const res = await acnGet(
+        `/agents/${agentId}/follows`,
+        params
+      );
+      const agents = res.agents ?? [];
+      if (agents.length === 0) {
+        output(res, "Not following anyone.");
+        return;
+      }
+      output(
+        res,
+        `Following ${res.total ?? agents.length} agent(s):
+
+` + agents.map((a, i) => formatAgent2(a, i)).join("\n\n")
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  cmd.command("followers").description("List agents that follow you").option("--limit <n>", "Max results", parseInt).option("--offset <n>", "Pagination offset", parseInt).option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (opts) => {
+    const agentId = opts.agentId ?? requireAgentId5();
+    try {
+      const params = {};
+      if (opts.limit !== void 0) params.limit = opts.limit;
+      if (opts.offset !== void 0) params.offset = opts.offset;
+      const res = await acnGet(
+        `/agents/${agentId}/followers`,
+        params
+      );
+      const agents = res.agents ?? [];
+      if (agents.length === 0) {
+        output(res, "No followers yet.");
+        return;
+      }
+      output(
+        res,
+        `${res.total ?? agents.length} follower(s):
+
+` + agents.map((a, i) => formatAgent2(a, i)).join("\n\n")
+      );
+    } catch (err) {
+      handleError(err);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/wallet.ts
+var import_commander12 = require("commander");
+function requireAgentId6() {
+  const config = loadConfig();
+  if (!config.api_key) {
+    console.error("No API key found. Run `acn join` first or `acn config set api-key <key>`.");
+    process.exit(1);
+  }
+  if (!config.agent_id) {
+    console.error("No agent ID found. Run `acn join` first or `acn config set agent-id <id>`.");
+    process.exit(1);
+  }
+  return config.agent_id;
+}
+function walletCommand() {
+  return new import_commander12.Command("wallet").description("View agent's wallet and payment info").option("-i, --agent-id <id>", "Agent ID (defaults to config)").action(async (opts) => {
+    const agentId = opts.agentId ?? requireAgentId6();
+    try {
+      const res = await acnGet(`/agents/${agentId}/wallets`);
+      const lines = [`Agent  : ${res.agent_id}`];
+      if (res.accepts_payment !== void 0)
+        lines.push(`Accepts payment : ${res.accepts_payment}`);
+      if (res.payment_methods?.length)
+        lines.push(`Methods : ${res.payment_methods.join(", ")}`);
+      if (res.wallet_addresses && Object.keys(res.wallet_addresses).length) {
+        lines.push("Wallets :");
+        for (const [chain, addr] of Object.entries(res.wallet_addresses)) {
+          lines.push(`  ${chain.padEnd(10)}: ${addr}`);
+        }
+      }
+      if (res.erc8004) {
+        lines.push(`ERC-8004: token_id=${res.erc8004.token_id} chain=${res.erc8004.chain}`);
+      }
+      if (res.token_pricing) {
+        lines.push(`Pricing : ${JSON.stringify(res.token_pricing)}`);
+      }
+      output(res, lines.join("\n"));
+    } catch (err) {
+      handleError(err);
+    }
+  });
+}
+
+// src/index.ts
+var program = new import_commander13.Command();
+program.name("acn").description("ACN CLI \u2014 Agent Collaboration Network command-line interface").version("0.1.0").option("--json", "Output raw JSON (useful for agent parsing)").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.json) setJsonMode(true);
+});
+program.addCommand(configCommand());
+program.addCommand(joinCommand());
+program.addCommand(heartbeatCommand());
+program.addCommand(agentsCommand());
+program.addCommand(tasksCommand());
+program.addCommand(messageCommand());
+program.addCommand(notifyCommand());
+program.addCommand(inboxCommand());
+program.addCommand(sessionCommand());
+program.addCommand(subnetCommand());
+program.addCommand(followCommand());
+program.addCommand(walletCommand());
+program.parse(process.argv);