@botiverse/raft-daemon 0.58.1 → 0.59.0

package/dist/{dist-ADWW7UHH.js → dist-CLQ4P4XZ.js}

@@ -175,6 +175,7 @@ function emitCliTransportNormalizedError(attrs, env = process.env) {
 function routeFamilyForPath(pathname) {
   const normalized = pathname.split("?")[0] || "/";
   if (normalized === "/internal/agent-api/send") return "agent-api/send";
+  if (normalized === "/internal/agent-api/activity") return "agent-api/activity";
   if (normalized === "/internal/agent-api/events") return "agent-api/events";
   if (normalized === "/internal/agent-api/inbox") return "agent-api/inbox";
   if (normalized === "/internal/agent-api/receive-ack") return "agent-api/events";
@@ -332,6 +333,9 @@ var ApiClient = class {
     if (suffix === "/reminders" || suffix.startsWith("/reminders?") || suffix.startsWith("/reminders/")) {
       return `/internal/agent-api${suffix}`;
     }
+    if (suffix === "/mention-actions/pending" || suffix === "/mention-actions/execute") {
+      return `/internal/agent-api${suffix}`;
+    }
     if (suffix === "/receive" || suffix.startsWith("/receive?")) {
       return "/internal/agent-api/events?since=latest";
     }
@@ -15526,6 +15530,11 @@ var SERVER_CAPABILITY_MATRIX = {
     joinPublicChannels: true
   })
 };
+var EXTERNAL_AGENT_ACTIVITY_EVENT_SCHEMA = "raft-activity.v1";
+var EXTERNAL_AGENT_ACTIVITY_DRAIN_SCHEMA = "raft-activity-drain.v1";
+var EXTERNAL_AGENT_ACTIVITY_INGEST_SCHEMA = "raft-agent-activity-ingest.v1";
+var EXTERNAL_AGENT_ACTIVITY_TEXT_LIMIT = 4096;
+var EXTERNAL_AGENT_ACTIVITY_TOOL_NAME_LIMIT = 120;
 var EXTERNAL_AGENT_RUNTIME_ID = "external";
 var EXTERNAL_AGENT_RUNTIME_MODEL = "external";
 var EXTERNAL_AGENT_RUNTIME_DISPLAY_NAME = "External agent";
@@ -15820,6 +15829,15 @@ async function runAgentCommsBridgeOnce(input) {
   }
   const fetchedLastSeq = typeof fetched.last_seen_hint_seq === "number" ? fetched.last_seen_hint_seq : typeof fetched.last_hint_seq === "number" ? fetched.last_hint_seq : void 0;
   if (typeof fetchedLastSeq === "number") lastSeenHintSeq = Math.max(lastSeenHintSeq ?? 0, fetchedLastSeq);
+  if (input.activitySource && input.activitySink) {
+    output.push(await drainAndForwardActivity({
+      identity,
+      source: input.activitySource,
+      sink: input.activitySink,
+      max: input.activityDrainLimit ?? input.limit ?? 50,
+      now
+    }));
+  }
   store.writeSession({
     coreSessionId,
     ...typeof lastSeenHintSeq === "number" ? { lastSeenHintSeq } : {}
@@ -15827,6 +15845,126 @@ async function runAgentCommsBridgeOnce(input) {
   output.push(lifecycle(identity, processedHintCount > 0 ? "handoff_pending" : "listening_idle", now));
   return output;
 }
+async function drainAndForwardActivity(input) {
+  let drained;
+  try {
+    drained = await input.source.drainActivity({ max: input.max });
+  } catch (err) {
+    return activityDrainEvent(input.identity, input.now, {
+      outcome: "failed",
+      drainedCount: 0,
+      forwardedCount: 0,
+      rejectedCount: 0,
+      droppedCount: 0,
+      errorClass: err instanceof Error ? err.name : typeof err,
+      errorMessage: errorMessage2(err)
+    });
+  }
+  if (drained.schema !== EXTERNAL_AGENT_ACTIVITY_DRAIN_SCHEMA || !Array.isArray(drained.events)) {
+    return activityDrainEvent(input.identity, input.now, {
+      outcome: "failed",
+      drainedCount: 0,
+      forwardedCount: 0,
+      rejectedCount: 0,
+      droppedCount: normalizeNonNegativeInteger(drained.dropped),
+      errorClass: "ProtocolError",
+      errorMessage: "activity drain response did not match raft-activity-drain.v1"
+    });
+  }
+  const sanitized = sanitizeExternalAgentActivityEvents(drained.events, input.now);
+  if (sanitized.events.length === 0) {
+    return activityDrainEvent(input.identity, input.now, {
+      outcome: "no_events",
+      drainedCount: drained.events.length,
+      forwardedCount: 0,
+      rejectedCount: sanitized.rejectedCount,
+      droppedCount: normalizeNonNegativeInteger(drained.dropped)
+    });
+  }
+  try {
+    await input.sink.forwardActivity({
+      schema: EXTERNAL_AGENT_ACTIVITY_INGEST_SCHEMA,
+      coreSessionId: input.identity.coreSessionId,
+      adapterInstance: input.identity.adapterInstance,
+      events: sanitized.events,
+      dropped: normalizeNonNegativeInteger(drained.dropped)
+    });
+  } catch (err) {
+    return activityDrainEvent(input.identity, input.now, {
+      outcome: "failed",
+      drainedCount: drained.events.length,
+      forwardedCount: 0,
+      rejectedCount: sanitized.rejectedCount,
+      droppedCount: normalizeNonNegativeInteger(drained.dropped),
+      errorClass: err instanceof Error ? err.name : typeof err,
+      errorMessage: errorMessage2(err)
+    });
+  }
+  return activityDrainEvent(input.identity, input.now, {
+    outcome: "forwarded",
+    drainedCount: drained.events.length,
+    forwardedCount: sanitized.events.length,
+    rejectedCount: sanitized.rejectedCount,
+    droppedCount: normalizeNonNegativeInteger(drained.dropped)
+  });
+}
+function sanitizeExternalAgentActivityEvents(rawEvents, now = () => /* @__PURE__ */ new Date()) {
+  const events = [];
+  let rejectedCount = 0;
+  for (const raw of rawEvents) {
+    const hookEventName = stringField(raw.hookEventName ?? raw.hook_event_name, 80);
+    if (!hookEventName) {
+      rejectedCount += 1;
+      continue;
+    }
+    const eventId = stringField(raw.eventId ?? raw.event_id, 160) ?? `event_${randomUUID()}`;
+    const sessionId = stringField(raw.sessionId ?? raw.session_id, 200);
+    const toolName = stringField(raw.toolName ?? raw.tool_name, EXTERNAL_AGENT_ACTIVITY_TOOL_NAME_LIMIT);
+    const status = stringField(raw.status, 40);
+    const errorClass = stringField(raw.errorClass ?? raw.error_class, 120);
+    const occurredAt = validIsoDate(raw.occurredAt ?? raw.occurred_at) ?? now().toISOString();
+    const durationMs = normalizeNonNegativeInteger(raw.durationMs ?? raw.duration_ms);
+    const toolInput = truncateActivityText(
+      raw.toolInput ?? raw.tool_input,
+      raw.toolInputTruncated ?? raw.tool_input_truncated ?? raw.truncated
+    );
+    const toolOutput = truncateActivityText(
+      raw.toolOutput ?? raw.tool_output,
+      raw.toolOutputTruncated ?? raw.tool_output_truncated ?? raw.truncated
+    );
+    events.push({
+      schema: EXTERNAL_AGENT_ACTIVITY_EVENT_SCHEMA,
+      eventId,
+      ...sessionId ? { sessionId } : {},
+      hookEventName,
+      ...toolName ? { toolName } : {},
+      ...status ? { status } : {},
+      occurredAt,
+      ...durationMs > 0 ? { durationMs } : {},
+      ...errorClass ? { errorClass } : {},
+      ...toolInput.text !== void 0 ? { toolInput: toolInput.text, toolInputTruncated: toolInput.truncated } : {},
+      ...toolOutput.text !== void 0 ? { toolOutput: toolOutput.text, toolOutputTruncated: toolOutput.truncated } : {}
+    });
+  }
+  return { events, rejectedCount };
+}
+function activityDrainEvent(identity, now, result2) {
+  return {
+    type: "agent_comms.activity_drain",
+    eventId: `event_${randomUUID()}`,
+    protocolVersion: AGENT_COMMS_PROTOCOL_VERSION,
+    timestamp: now().toISOString(),
+    coreSessionId: identity.coreSessionId,
+    agentId: identity.agentId,
+    profile: identity.profileSlug,
+    profileSlug: identity.profileSlug,
+    adapterInstance: identity.adapterInstance,
+    runtimeSession: null,
+    source: "slock-agent-bridge",
+    provenance: commsCoreProvenance("comms_core"),
+    ...result2
+  };
+}
 var BRIDGE_LOG_MAX_BYTES = 5 * 1024 * 1024;
 function rotateBridgeLogIfNeeded(logFile) {
   try {
@@ -16156,6 +16294,46 @@ function stripContentFields(wakeHint) {
   delete clone2.message;
   return clone2;
 }
+function stringField(value, maxLength) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.replace(/\s+/g, " ").trim();
+  if (!trimmed) return void 0;
+  return trimmed.slice(0, maxLength);
+}
+function validIsoDate(value) {
+  if (typeof value !== "string") return void 0;
+  const parsed = Date.parse(value);
+  if (Number.isNaN(parsed)) return void 0;
+  return new Date(parsed).toISOString();
+}
+function normalizeNonNegativeInteger(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return 0;
+  return Math.floor(value);
+}
+function truncateActivityText(value, alreadyTruncated) {
+  if (value === void 0 || value === null) return { truncated: Boolean(alreadyTruncated) };
+  let text;
+  if (typeof value === "string") {
+    text = value;
+  } else {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = String(value);
+    }
+  }
+  const marker = "\n[truncated]";
+  if (text.length > EXTERNAL_AGENT_ACTIVITY_TEXT_LIMIT) {
+    return {
+      text: `${text.slice(0, Math.max(0, EXTERNAL_AGENT_ACTIVITY_TEXT_LIMIT - marker.length))}${marker}`,
+      truncated: true
+    };
+  }
+  return { text, truncated: Boolean(alreadyTruncated) };
+}
+function errorMessage2(err) {
+  return (err instanceof Error ? err.message : String(err)).slice(0, 200);
+}
 function safePathSegment(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 120) || "unknown";
 }
@@ -16309,7 +16487,10 @@ var agentBridgeCommand = defineCommand(
       { flags: "--wake-channel-endpoint <url>", description: "Localhost wake endpoint exposed by the runtime's Raft channel plugin (see docs/wake-endpoint-contract.md in raft-external-agents)." },
       { flags: "--wake-channel-token <token>", description: "Optional shared token for the Raft channel wake endpoint (env: RAFT_CHANNEL_TOKEN)." },
       { flags: "--runtime-session <id>", description: "Optional runtime session id when the adapter endpoint does not return one." },
-      { flags: "--reconcile-interval-ms <ms>", description: "Re-peek the full server-pending set every <ms> and re-wake hints that were injected but never consumed (0 disables; default 120000)." }
+      { flags: "--reconcile-interval-ms <ms>", description: "Re-peek the full server-pending set every <ms> and re-wake hints that were injected but never consumed (0 disables; default 120000)." },
+      { flags: "--activity-channel-endpoint <url>", description: "Localhost activity drain endpoint exposed by the runtime's Raft channel plugin. Defaults to /activity/drain derived from --wake-channel-endpoint." },
+      { flags: "--activity-channel-token <token>", description: "Optional shared token for the activity drain endpoint (env: RAFT_CHANNEL_TOKEN)." },
+      { flags: "--activity-drain-limit <n>", description: "Maximum plugin activity events to drain per bridge iteration." }
     ]
   },
   async (ctx, options) => {
@@ -16324,10 +16505,13 @@ var agentBridgeCommand = defineCommand(
     const pollIntervalMs = parsePositiveInt(options.pollIntervalMs, 5e3, "poll-interval-ms");
     const reconcileIntervalMs = options.reconcileIntervalMs === "0" ? 0 : parsePositiveInt(options.reconcileIntervalMs, 12e4, "reconcile-interval-ms");
     const limit = parsePositiveInt(options.limit, 50, "limit");
+    const activityDrainLimit = parsePositiveInt(options.activityDrainLimit, 50, "activity-drain-limit");
     const client = ctx.createApiClient(agentContext);
     const pollSource = createAgentApiWakeHintSource(client);
     const streamSource = options.once ? null : createAgentApiWakeHintStreamSource(client, ctx.env);
     const wakeAdapter = createWakeAdapter(options, ctx.env);
+    const activitySource = createActivityDrainSource(options, ctx.env);
+    const activitySink = activitySource ? createAgentApiActivitySink(client) : void 0;
     let bridgeLock;
     try {
       bridgeLock = acquireAgentCommsBridgeLock({
@@ -16381,6 +16565,9 @@ var agentBridgeCommand = defineCommand(
             replayPending,
             wakeAdapter,
             runtimeSession: options.runtimeSession ?? null,
+            activitySource,
+            activitySink,
+            activityDrainLimit,
             recentInjections
           });
           for (const event of events) emit(event);
@@ -16663,6 +16850,59 @@ function createWakeAdapter(options, env = process.env) {
     token: options.wakeChannelToken ?? env.RAFT_CHANNEL_TOKEN
   });
 }
+function createActivityDrainSource(options, env = process.env) {
+  const endpointUrl = options.activityChannelEndpoint ?? deriveActivityDrainEndpoint(options.wakeChannelEndpoint);
+  if (!endpointUrl) return void 0;
+  const token = options.activityChannelToken ?? options.wakeChannelToken ?? env.RAFT_CHANNEL_TOKEN;
+  return {
+    async drainActivity(input) {
+      const url2 = new URL(endpointUrl);
+      url2.searchParams.set("max", String(input.max));
+      const signal = typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(3e3) : void 0;
+      const response = await fetch(url2, {
+        method: "GET",
+        signal,
+        headers: {
+          ...token ? { "x-raft-bridge-token": token } : {}
+        }
+      });
+      const contentType = response.headers.get("content-type") ?? "";
+      const data = contentType.includes("application/json") ? await response.json() : {};
+      if (!response.ok) {
+        throw new CliError({
+          code: response.status >= 500 ? "SERVER_5XX" : "BRIDGE_ACTIVITY_DRAIN_FAILED",
+          message: typeof data?.error === "string" ? data.error : `HTTP ${response.status}`
+        });
+      }
+      return data;
+    }
+  };
+}
+function createAgentApiActivitySink(client) {
+  return {
+    async forwardActivity(input) {
+      const response = await client.request("POST", "/internal/agent-api/activity", input);
+      if (!response.ok) {
+        throw new CliError({
+          code: response.status >= 500 ? "SERVER_5XX" : "BRIDGE_ACTIVITY_FORWARD_FAILED",
+          message: response.error ?? `HTTP ${response.status}`
+        });
+      }
+    }
+  };
+}
+function deriveActivityDrainEndpoint(wakeChannelEndpoint) {
+  if (!wakeChannelEndpoint) return void 0;
+  try {
+    const url2 = new URL(wakeChannelEndpoint);
+    url2.pathname = "/activity/drain";
+    url2.search = "";
+    url2.hash = "";
+    return url2.toString();
+  } catch {
+    return void 0;
+  }
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -17548,6 +17788,84 @@ ${opts.heldAction} Review the bounded context shown here, then choose one path.$
 
 ` + (opts.draftInstructions ?? "") + continueAnyway;
 }
+function normalizeAction(action) {
+  if (action === "notify" || action === "notify_only") return "notify";
+  if (action === "invite" || action === "add") return "invite";
+  return null;
+}
+function formatActionCommands(action) {
+  const verbs = action.availableActions.map(normalizeAction).filter((verb) => verb !== null);
+  return Array.from(new Set(verbs)).map((verb) => `  ${verb}: slock mention ${verb} ${action.resolutionId}`);
+}
+function normalizePendingMentionActions(data) {
+  const value = data;
+  const raw = Array.isArray(value?.pendingMentionActions) ? value.pendingMentionActions : Array.isArray(value?.actions) ? value.actions : Array.isArray(value?.results) ? value.results : [];
+  return raw.filter((item) => Boolean(item && typeof item === "object")).map((item) => ({
+    resolutionId: String(item.resolutionId ?? item.id ?? ""),
+    messageId: String(item.messageId ?? ""),
+    targetType: String(item.targetType ?? "unknown"),
+    targetHandle: String(item.targetHandle ?? ""),
+    reason: String(item.reason ?? "Mention target was not notified at send time."),
+    availableActions: Array.isArray(item.availableActions) ? item.availableActions.map(String) : [],
+    expiresAt: typeof item.expiresAt === "string" ? item.expiresAt : null
+  })).filter((item) => item.resolutionId.length > 0);
+}
+function normalizeMentionActionResults(data) {
+  const value = data;
+  const raw = Array.isArray(value?.results) ? value.results : Array.isArray(value?.actionResults) ? value.actionResults : [];
+  return raw.filter((item) => Boolean(item && typeof item === "object")).map((item) => ({
+    resolutionId: String(item.resolutionId ?? item.id ?? ""),
+    status: String(item.status ?? "not_found"),
+    action: typeof item.action === "string" ? normalizeAction(item.action) : null,
+    messageId: typeof item.messageId === "string" ? item.messageId : null,
+    channelId: typeof item.channelId === "string" ? item.channelId : null,
+    targetType: typeof item.targetType === "string" ? item.targetType : null,
+    targetId: typeof item.targetId === "string" ? item.targetId : null,
+    targetHandle: typeof item.targetHandle === "string" ? item.targetHandle : null,
+    message: typeof item.message === "string" ? item.message : null,
+    reason: typeof item.reason === "string" ? item.reason : null,
+    dedupedResolutionIds: Array.isArray(item.dedupedResolutionIds) ? item.dedupedResolutionIds.filter((id) => typeof id === "string" && id.length > 0) : []
+  })).filter((item) => item.resolutionId.length > 0);
+}
+function formatPendingMentionActions(actions, opts = {}) {
+  if (actions.length === 0) {
+    return opts.source === "pending" ? "Pending mention actions\n\nNo pending mention actions.\n" : "";
+  }
+  const lines = ["Pending mention actions", ""];
+  for (const action of actions) {
+    const target = action.targetHandle ? `${action.targetHandle} (${action.targetType})` : action.targetType;
+    lines.push(`- ${action.resolutionId} \u2014 ${target}`);
+    if (action.messageId) lines.push(`  message: ${action.messageId}`);
+    lines.push(`  reason: ${action.reason}`);
+    if (action.expiresAt) lines.push(`  expires: ${action.expiresAt}`);
+    const commands = formatActionCommands(action);
+    if (commands.length > 0) {
+      lines.push("  available commands:");
+      lines.push(...commands);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatMentionActionResults(action, results) {
+  const lines = [`Mention ${action} results`, ""];
+  if (results.length === 0) {
+    lines.push("No result rows returned.");
+    return `${lines.join("\n")}
+`;
+  }
+  for (const result2 of results) {
+    const target = result2.targetHandle ? ` ${result2.targetHandle}` : "";
+    const detail = result2.message ?? result2.reason;
+    const suffix = detail ? ` \u2014 ${detail}` : "";
+    lines.push(`- ${result2.resolutionId}${target}: ${result2.status}${suffix}`);
+    if (result2.dedupedResolutionIds && result2.dedupedResolutionIds.length > 1) {
+      lines.push(`  deduped: ${result2.dedupedResolutionIds.join(", ")}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
 var DEFAULT_LOCAL_DRAFT_TTL_MS = 10 * 60 * 1e3;
 function stateFilePath2(agentId) {
   return path6.join(process.env.SLOCK_CLI_DRAFT_STATE_DIR ?? os3.tmpdir(), "slock-cli-attested-send", agentId, "continue-state.json");
@@ -17850,7 +18168,11 @@ var messageSendCommand = defineCommand(
 --- New messages you may have missed ---
 ${formatMessages(data.recentUnread)}`;
     }
-    writeText(ctx.io, `Message sent to ${opts.target}. Message ID: ${data.messageId}${replyHint}${unreadSection}
+    const pendingMentionActions = normalizePendingMentionActions(data);
+    const mentionSection = pendingMentionActions.length > 0 ? `
+
+${formatPendingMentionActions(pendingMentionActions, { source: "send" }).trimEnd()}` : "";
+    writeText(ctx.io, `Message sent to ${opts.target}. Message ID: ${data.messageId}${replyHint}${mentionSection}${unreadSection}
 `);
   }
 );
@@ -18906,6 +19228,77 @@ var taskUpdateCommand = defineCommand(
 function registerTaskUpdateCommand(parent, runtimeOptions) {
   registerCliCommand(parent, taskUpdateCommand, runtimeOptions);
 }
+function normalizeResolutionIds(rawIds) {
+  const ids = (rawIds ?? []).map((id) => id.trim()).filter(Boolean);
+  if (ids.length === 0) {
+    throw cliError("INVALID_ARG", "At least one resolution id is required.");
+  }
+  return ids;
+}
+function buildMentionExecuteCommand(action) {
+  return defineCommand(
+    {
+      name: action,
+      description: `${action === "notify" ? "Notify" : "Invite"} unresolved mention targets by resolution id`,
+      arguments: ["<resolutionIds...>"],
+      options: [{ flags: "--json", description: "Emit machine-readable JSON" }]
+    },
+    async (ctx, resolutionIds, opts = {}) => {
+      const ids = normalizeResolutionIds(resolutionIds);
+      const agentContext = ctx.loadAgentContext();
+      const client = ctx.createApiClient(agentContext);
+      const res = await client.request(
+        "POST",
+        `/internal/agent/${encodeURIComponent(agentContext.agentId)}/mention-actions/execute`,
+        { action, resolutionIds: ids }
+      );
+      if (!res.ok || !res.data) {
+        throw cliError(res.status >= 500 ? "SERVER_5XX" : "MENTION_ACTION_FAILED", res.error ?? `HTTP ${res.status}`);
+      }
+      const results = normalizeMentionActionResults(res.data);
+      if (opts.json) {
+        writeJson(ctx.io, { ok: true, action, results });
+        return;
+      }
+      writeText(ctx.io, formatMentionActionResults(action, results));
+    }
+  );
+}
+function registerMentionExecuteCommands(parent, runtimeOptions = {}) {
+  registerCliCommand(parent, buildMentionExecuteCommand("notify"), runtimeOptions);
+  registerCliCommand(parent, buildMentionExecuteCommand("invite"), runtimeOptions);
+}
+var mentionPendingCommand = defineCommand(
+  {
+    name: "pending",
+    description: "List sender-side pending mention actions",
+    options: [{ flags: "--json", description: "Emit machine-readable JSON" }]
+  },
+  async (ctx, opts = {}) => {
+    const agentContext = ctx.loadAgentContext();
+    const client = ctx.createApiClient(agentContext);
+    const res = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(agentContext.agentId)}/mention-actions/pending`
+    );
+    if (!res.ok || !res.data) {
+      throw cliError(res.status >= 500 ? "SERVER_5XX" : "MENTION_PENDING_FAILED", res.error ?? `HTTP ${res.status}`);
+    }
+    const actions = normalizePendingMentionActions(res.data);
+    if (opts.json) {
+      writeJson(ctx.io, { ok: true, pendingMentionActions: actions });
+      return;
+    }
+    writeText(ctx.io, formatPendingMentionActions(actions, { source: "pending" }));
+  }
+);
+function registerMentionPendingCommand(parent, runtimeOptions = {}) {
+  registerCliCommand(parent, mentionPendingCommand, runtimeOptions);
+}
+function registerMentionCommands(parent, runtimeOptions = {}) {
+  registerMentionPendingCommand(parent, runtimeOptions);
+  registerMentionExecuteCommands(parent, runtimeOptions);
+}
 function formatCreatedAgents(createdAgents) {
   if (createdAgents.length === 0) {
     return ["- Created Agents: none"];
@@ -20181,6 +20574,8 @@ registerTaskCreateCommand(taskCmd);
 registerTaskClaimCommand(taskCmd);
 registerTaskUnclaimCommand(taskCmd);
 registerTaskUpdateCommand(taskCmd);
+var mentionCmd = program.command("mention").description("Sender-side mention action operations");
+registerMentionCommands(mentionCmd);
 var profileCmd = program.command("profile").description("Profile operations");
 registerProfileShowCommand(profileCmd);
 registerProfileUpdateCommand(profileCmd);

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-G324C7NF.js";
+} from "./chunk-FTEZQN4P.js";
 
 // src/index.ts
 var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botiverse/raft-daemon",
-  "version": "0.58.1",
+  "version": "0.59.0",
   "type": "module",
   "bin": {
     "raft-daemon": "dist/raft-daemon.js",