@botiverse/raft-daemon 0.70.2 → 0.71.0

package/dist/cli/index.js

@@ -28001,6 +28001,7 @@ var CliError = class extends Error {
   code;
   exitCode;
   suggestedNextAction;
+  draftSaved;
   constructor(options) {
     super(options.message);
     this.name = "CliError";
@@ -28008,6 +28009,7 @@ var CliError = class extends Error {
     this.exitCode = options.exitCode ?? 1;
     this.cause = options.cause;
     this.suggestedNextAction = options.suggestedNextAction;
+    this.draftSaved = options.draftSaved;
   }
 };
 var CliExit = class extends Error {
@@ -28034,7 +28036,8 @@ function cliError(code, message, options = {}) {
     message,
     exitCode: options.exitCode,
     cause: options.cause,
-    suggestedNextAction: options.suggestedNextAction
+    suggestedNextAction: options.suggestedNextAction,
+    draftSaved: options.draftSaved
   });
 }
 function toCliError(err) {
@@ -28823,6 +28826,18 @@ function defineTraceFields(definitions) {
   }
   return definitions;
 }
+var TRACE_LIFECYCLE_SHADOW_SIGNAL_SITE_VALUES = [
+  "daemon_ingest",
+  "delivery_ack",
+  "hint_resolution",
+  "lifecycle_plan",
+  "preserve_rebroadcast",
+  "ready_online",
+  "runtime_error",
+  "slock_action_status",
+  "starting_resolve",
+  "synthetic_repair"
+];
 var TRACE_B0_FIELD_DEFINITIONS = defineTraceFields([
   { key: "row_kind", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "stable" },
   { key: "trace_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
@@ -28845,10 +28860,13 @@ var TRACE_B0_FIELD_DEFINITIONS = defineTraceFields([
   { key: "route_pattern", fieldClass: "query_axis", placement: "span", valueKind: "route" },
   { key: "caller_kind", fieldClass: "query_axis", placement: "span", valueKind: "closed_enum", enumBinding: "stable" },
   { key: "server_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "channel_id", fieldClass: "query_axis", placement: "span_or_event", valueKind: "identity", highCardinality: true },
   { key: "machine_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
   { key: "agent_id", fieldClass: "query_axis", placement: "span_or_event", valueKind: "identity", highCardinality: true },
+  { key: "job_id", fieldClass: "query_axis", placement: "span_or_event", valueKind: "identity", highCardinality: true },
   { key: "launch_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
   { key: "session_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "outcome", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
   { key: "observation_class", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
   { key: "action", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
   { key: "source", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
@@ -28858,6 +28876,7 @@ var TRACE_B0_FIELD_DEFINITIONS = defineTraceFields([
   { key: "error_class", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
   { key: "query_name", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "query_registry" },
   { key: "phase", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "eligibility_subcheck", fieldClass: "query_axis", placement: "event", valueKind: "closed_enum", enumBinding: "pending_457" },
   { key: "hint_source", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
   { key: "resolved_activity", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
   { key: "previous_activity", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
@@ -28867,7 +28886,7 @@ var TRACE_B0_FIELD_DEFINITIONS = defineTraceFields([
   { key: "activity_source", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
   { key: "status_bucket", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
   { key: "shadow_agent_id", fieldClass: "family_query_axis", placement: "event", valueKind: "identity", scope: "family:lifecycle_shadow", highCardinality: true },
-  { key: "shadow_signal_site", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_signal_site", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457", enumValues: TRACE_LIFECYCLE_SHADOW_SIGNAL_SITE_VALUES },
   { key: "shadow_observation_class", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
   { key: "shadow_prior_projection", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
   { key: "shadow_projection", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
@@ -28877,6 +28896,8 @@ var TRACE_B0_FIELD_DEFINITIONS = defineTraceFields([
   { key: "shadow_direction", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
   { key: "shadow_plan_kind", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
   { key: "row_count", fieldClass: "detail", placement: "span_or_event", valueKind: "detail" },
+  { key: "rows_copied", fieldClass: "detail", placement: "span_or_event", valueKind: "numeric" },
+  { key: "batch_index", fieldClass: "detail", placement: "span_or_event", valueKind: "numeric" },
   { key: "retry_count", fieldClass: "detail", placement: "span_or_event", valueKind: "detail" },
   { key: "error_message", fieldClass: "detail", placement: "span_or_event", valueKind: "detail", contentRule: "scrub_and_short_retention" },
   { key: "query_text", fieldClass: "content_safety", placement: "span_or_event", valueKind: "content", contentRule: "scrub_and_short_retention" },
@@ -42927,6 +42948,24 @@ var agentApiKnowledgeGetResponseSchema = passthroughObject({
   contentType: external_exports.string(),
   content: external_exports.string()
 });
+var agentApiKnowledgeSearchQuerySchema = passthroughObject({
+  query: external_exports.string().trim().min(1),
+  scope: optionalStringSchema,
+  reason: optionalStringSchema,
+  turn_id: optionalStringSchema,
+  trace_id: optionalStringSchema
+});
+var agentApiKnowledgeSearchResultSchema = passthroughObject({
+  slug: external_exports.string(),
+  title: external_exports.string(),
+  firstScreen: external_exports.string()
+});
+var agentApiKnowledgeSearchResponseSchema = passthroughObject({
+  ok: external_exports.literal(true),
+  query: external_exports.string(),
+  scope: external_exports.string().nullable(),
+  results: external_exports.array(agentApiKnowledgeSearchResultSchema)
+});
 var agentApiMessageSearchQuerySchema = passthroughObject({
   q: optionalStringSchema,
   channel: optionalStringSchema,
@@ -43378,7 +43417,14 @@ var agentApiSendSentResponseSchema = passthroughObject({
   messageId: external_exports.string(),
   messageSeq: optionalNumberSchema,
   recentUnread: external_exports.array(agentApiMessageEnvelopeSchema).optional(),
-  pendingMentionActions: external_exports.array(agentApiMessageEnvelopeSchema).optional()
+  pendingMentionActions: external_exports.array(agentApiMessageEnvelopeSchema).optional(),
+  attention: passthroughObject({
+    driveByJoinedToPost: passthroughObject({
+      reason: optionalStringSchema,
+      muteCommand: optionalStringSchema,
+      stillArrives: optionalStringArraySchema
+    }).optional()
+  }).optional()
 });
 var agentApiSendResponseSchema = external_exports.discriminatedUnion("state", [
   agentApiSendSentResponseSchema,
@@ -43567,6 +43613,16 @@ var agentApiContract = {
     request: { query: agentApiKnowledgeGetQuerySchema },
     response: { body: agentApiKnowledgeGetResponseSchema }
   }),
+  knowledgeSearch: route({
+    key: "knowledgeSearch",
+    method: "GET",
+    path: "/knowledge/search",
+    client: { resource: "knowledge", method: "search" },
+    capability: "knowledge",
+    description: "Search Slock Manual for Agents topics from the current server.",
+    request: { query: agentApiKnowledgeSearchQuerySchema },
+    response: { body: agentApiKnowledgeSearchResponseSchema }
+  }),
   messageSend: route({
     key: "messageSend",
     method: "POST",
@@ -44868,7 +44924,8 @@ var SUPPORTED_TRANSLATION_LANGUAGE_CODES = [
   "es",
   "fr",
   "de",
-  "pt-br"
+  "pt-br",
+  "it"
 ];
 var SUPPORTED_TRANSLATION_LANGUAGE_SET = new Set(
   SUPPORTED_TRANSLATION_LANGUAGE_CODES
@@ -45000,6 +45057,15 @@ var SERVER_CAPABILITY_MATRIX = {
   })
 };
 
+// ../shared/src/tracing/traceFamilyRegistry.ts
+init_esm_shims();
+
+// ../shared/src/tracing/stateTransitionTrace.ts
+init_esm_shims();
+
+// ../shared/src/tracing/stateViolationTrace.ts
+init_esm_shims();
+
 // ../shared/src/index.ts
 var BUILTIN_RUNTIME_PROVIDER_ENV_KEYS = PI_BUILTIN_PROVIDER_API_KEY_ENV_KEYS_GENERATED;
 var BUILTIN_RUNTIME_PROVIDERS = Object.entries(BUILTIN_RUNTIME_PROVIDER_ENV_KEYS).map(([id, envKey]) => ({ id, envKey }));
@@ -45442,7 +45508,8 @@ function createAgentApiSurfaceClient(client) {
       read: (query) => requestClientAsApiResponse(agentApi.history.read(query))
     },
     knowledge: {
-      get: (query) => requestClientAsApiResponse(agentApi.knowledge.get(query))
+      get: (query) => requestClientAsApiResponse(agentApi.knowledge.get(query)),
+      search: (query) => requestClientAsApiResponse(agentApi.knowledge.search(query))
     },
     tasks: {
       list: (query) => requestClientAsApiResponse(agentApi.tasks.list(query)),
@@ -46193,6 +46260,10 @@ function renderError(io, err) {
 `);
   io.stderr.write(`Code: ${err.code}
 `);
+  if (err.draftSaved !== void 0) {
+    io.stderr.write(`Draft saved: ${err.draftSaved ? "yes" : "no"}
+`);
+  }
   if (err.suggestedNextAction) {
     io.stderr.write(`Next action: ${err.suggestedNextAction}
 `);
@@ -48557,6 +48628,156 @@ function formatServerInfo(data) {
   }
   return text;
 }
+function channelRef(name) {
+  return name.startsWith("#") ? name : `#${name}`;
+}
+function channelVisibility(channel) {
+  const type = channel.type?.trim();
+  return type === "private" ? "private" : "public";
+}
+function channelMuted(channel) {
+  if (typeof channel.muted === "boolean") return channel.muted;
+  if (typeof channel.activityMuted === "boolean") return channel.activityMuted;
+  return void 0;
+}
+function channelStatus(channel) {
+  const parts = [
+    channelVisibility(channel),
+    channel.joined ? "joined" : "not joined"
+  ];
+  const muted = channelMuted(channel);
+  if (muted !== void 0) parts.push(muted ? "muted" : "not muted");
+  if (typeof channel.archived === "boolean") parts.push(channel.archived ? "archived" : "not archived");
+  return parts.join(", ");
+}
+function formatPageFooter(page) {
+  if (!page) return "";
+  const start = page.total === 0 ? 0 : Math.min(page.offset + 1, page.total);
+  const end = Math.min(page.offset + page.limit, page.total);
+  const lines = [`
+Showing ${start}-${end} of ${page.total}.`];
+  if (page.nextCommand && end < page.total) {
+    lines.push(`More: ${page.nextCommand}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function formatChannelInfo(channel, memberCounts) {
+  const lines = ["## Channel", ""];
+  lines.push(`Channel: ${channelRef(channel.name)}`);
+  if (channel.id) lines.push(`ID: ${channel.id}`);
+  lines.push(`Visibility: ${channelVisibility(channel)}`);
+  lines.push(`Joined: ${channel.joined ? "yes" : "no"}`);
+  const muted = channelMuted(channel);
+  if (muted !== void 0) lines.push(`Muted: ${muted ? "yes" : "no"}`);
+  if (typeof channel.archived === "boolean") lines.push(`Archived: ${channel.archived ? "yes" : "no"}`);
+  lines.push(`Description: ${channel.description?.trim() || "(none)"}`);
+  if (memberCounts) {
+    const agents = memberCounts.agents ?? 0;
+    const humans = memberCounts.humans ?? 0;
+    lines.push(`Members: ${agents + humans} (${agents} agents, ${humans} humans)`);
+  }
+  lines.push("");
+  lines.push(`More: raft channel members "${channelRef(channel.name)}"`);
+  return `${lines.join("\n")}
+`;
+}
+function formatServerSummary(data) {
+  const channels = data.channels ?? [];
+  const agents = data.agents ?? [];
+  const humans = data.humans ?? [];
+  const joined = channels.filter((channel) => channel.joined).length;
+  const lines = [
+    "## Server",
+    "",
+    `Channels: ${channels.length} visible (${joined} joined)`,
+    `Agents: ${agents.length}`,
+    `Humans: ${humans.length}`,
+    "",
+    "Narrow queries:",
+    "- raft server info --channels",
+    "- raft server info --agents",
+    "- raft server info --humans",
+    "- raft channel info <name>",
+    "- raft user info <name>",
+    "",
+    "Full dump: raft server info --full"
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function formatServerChannels(channels, page) {
+  const lines = [
+    "## Server Channels",
+    "",
+    "Private channels are shown only when this agent is a member. Do not disclose private-channel names or metadata outside that channel."
+  ];
+  if (channels.length === 0) {
+    lines.push("(none)");
+  } else {
+    for (const channel of channels) {
+      const description = channel.description?.trim();
+      lines.push(description ? `${channelRef(channel.name)} [${channelStatus(channel)}] \u2014 ${description}` : `${channelRef(channel.name)} [${channelStatus(channel)}]`);
+    }
+  }
+  return `${lines.join("\n")}${formatPageFooter(page)}`;
+}
+function formatServerAgents(agents, page) {
+  const lines = [
+    "## Server Agents",
+    "",
+    "Role labels show server-level owner/admin authority; no role label means ordinary member."
+  ];
+  if (agents.length === 0) {
+    lines.push("(none)");
+  } else {
+    for (const agent of agents) {
+      const role = roleLabel(agent.role);
+      const status = agentStatusLabel(agent);
+      lines.push(agent.description ? `@${agent.name} (${status})${role} \u2014 ${agent.description}` : `@${agent.name} (${status})${role}`);
+    }
+  }
+  return `${lines.join("\n")}${formatPageFooter(page)}`;
+}
+function formatServerHumans(humans, page) {
+  const lines = [
+    "## Server Humans",
+    "",
+    "Role labels show server-level owner/admin authority; no role label means ordinary member."
+  ];
+  if (humans.length === 0) {
+    lines.push("(none)");
+  } else {
+    for (const human of humans) {
+      const role = roleLabel(human.role);
+      lines.push(human.description ? `@${human.name}${role} \u2014 ${human.description}` : `@${human.name}${role}`);
+    }
+  }
+  return `${lines.join("\n")}${formatPageFooter(page)}`;
+}
+function formatUserInfo(user, memberships, page, skippedChannels = 0) {
+  const name = user.value.name;
+  const role = roleLabel(user.value.role);
+  const lines = ["## User", ""];
+  lines.push(`User: @${name}`);
+  lines.push(`Kind: ${user.kind}`);
+  if (user.kind === "agent") lines.push(`Status: ${agentStatusLabel(user.value)}`);
+  if (role) lines.push(`Role: ${role.slice(2, -1)}`);
+  if (user.value.description) lines.push(`Description: ${user.value.description}`);
+  lines.push("");
+  lines.push("### Visible Channel Memberships");
+  if (memberships.length === 0) {
+    lines.push("(none found in inspected visible channels)");
+  } else {
+    for (const channel of memberships) {
+      lines.push(`${channelRef(channel.name)} [${channelStatus(channel)}]`);
+    }
+  }
+  if (skippedChannels > 0) {
+    lines.push(`Skipped ${skippedChannels} visible channel roster checks because the server rejected them.`);
+  }
+  return `${lines.join("\n")}${formatPageFooter(page)}`;
+}
 function formatChannelMembers(data) {
   let text = "## Channel Members\n\n";
   const ref = data.channel?.ref ?? "(unknown)";
@@ -48626,68 +48847,7 @@ function registerChannelMembersCommand(parent, runtimeOptions) {
   registerCliCommand(parent, channelMembersCommand, runtimeOptions);
 }
 
-// src/commands/channel/create.ts
-init_esm_shims();
-function normalizeChannelName(raw) {
-  return (raw ?? "").trim().replace(/^#/, "");
-}
-function formatCreateChannelResult(channel) {
-  const target = `#${channel.name}`;
-  const visibility = channel.type === "private" ? "private" : "public";
-  return `Created ${target} (${visibility}). You are joined and can send messages there.`;
-}
-var channelCreateCommand = defineCommand(
-  {
-    name: "create",
-    description: "Create a public or private channel when this agent has server admin authority",
-    options: [
-      {
-        flags: "--name <name>",
-        description: "Channel name, with or without a leading '#'"
-      },
-      {
-        flags: "--description <description>",
-        description: "Optional channel description"
-      },
-      {
-        flags: "--private",
-        description: "Create a private channel instead of a public channel"
-      }
-    ]
-  },
-  async (ctx, opts) => {
-    const name = normalizeChannelName(opts.name);
-    if (!name) {
-      throw new CliError({
-        code: "INVALID_ARG",
-        message: "--name is required"
-      });
-    }
-    const agentContext = ctx.loadAgentContext();
-    const client = ctx.createApiClient(agentContext);
-    const res = await client.request(
-      "POST",
-      `/internal/agent/${encodeURIComponent(agentContext.agentId)}/channels`,
-      {
-        name,
-        description: opts.description,
-        visibility: opts.private ? "private" : "public"
-      }
-    );
-    if (!res.ok || !res.data) {
-      throw new CliError({
-        code: res.status >= 500 ? "SERVER_5XX" : "CREATE_FAILED",
-        message: res.error ?? `HTTP ${res.status}`
-      });
-    }
-    writeText(ctx.io, formatCreateChannelResult(res.data) + "\n");
-  }
-);
-function registerChannelCreateCommand(parent, runtimeOptions) {
-  registerCliCommand(parent, channelCreateCommand, runtimeOptions);
-}
-
-// src/commands/channel/update.ts
+// src/commands/channel/info.ts
 init_esm_shims();
 
 // src/commands/channel/leave.ts
@@ -48761,7 +48921,123 @@ function registerChannelLeaveCommand(parent, runtimeOptions) {
   registerCliCommand(parent, channelLeaveCommand, runtimeOptions);
 }
 
+// src/commands/channel/info.ts
+function normalizeChannelInfoTarget(target) {
+  const input = target?.trim() ?? "";
+  const normalized = input.startsWith("#") ? input : `#${input}`;
+  const name = parseRegularChannelTarget(normalized);
+  if (!name) {
+    throw new CliError({
+      code: "INVALID_TARGET",
+      message: "Target must be a regular channel name, e.g. '#engineering' or 'engineering'. DMs and thread targets are not supported."
+    });
+  }
+  return { input: normalized, name };
+}
+var channelInfoCommand = defineCommand(
+  {
+    name: "info",
+    description: "Show narrow channel facts: existence, joined state, description, and member count when visible",
+    arguments: ["<target>"]
+  },
+  async (ctx, target) => {
+    const { input, name } = normalizeChannelInfoTarget(target);
+    const agentContext = ctx.loadAgentContext();
+    const client = ctx.createApiClient(agentContext);
+    const agentApi = createAgentApiSurfaceClient(client);
+    const infoRes = await agentApi.server.info();
+    if (!infoRes.ok) {
+      throw new CliError({
+        code: infoRes.status >= 500 ? "SERVER_5XX" : "INFO_FAILED",
+        message: infoRes.error ?? `HTTP ${infoRes.status}`
+      });
+    }
+    const channel = (infoRes.data?.channels ?? []).find((candidate) => candidate.name === name);
+    if (!channel) {
+      throw new CliError({
+        code: "NOT_FOUND",
+        message: `Channel not found or not visible: ${input}`,
+        suggestedNextAction: "Run `raft server info --channels --query <name>` to inspect visible channels, or ask a channel member to add you if this is private."
+      });
+    }
+    let memberCounts = null;
+    const membersRes = await agentApi.channels.members({ channel: `#${name}` });
+    if (membersRes.ok) {
+      memberCounts = {
+        agents: membersRes.data?.agents?.length ?? 0,
+        humans: membersRes.data?.humans?.length ?? 0
+      };
+    }
+    writeText(ctx.io, formatChannelInfo(channel, memberCounts));
+  }
+);
+function registerChannelInfoCommand(parent, runtimeOptions) {
+  registerCliCommand(parent, channelInfoCommand, runtimeOptions);
+}
+
+// src/commands/channel/create.ts
+init_esm_shims();
+function normalizeChannelName(raw) {
+  return (raw ?? "").trim().replace(/^#/, "");
+}
+function formatCreateChannelResult(channel) {
+  const target = `#${channel.name}`;
+  const visibility = channel.type === "private" ? "private" : "public";
+  return `Created ${target} (${visibility}). You are joined and can send messages there.`;
+}
+var channelCreateCommand = defineCommand(
+  {
+    name: "create",
+    description: "Create a public or private channel when this agent has server admin authority",
+    options: [
+      {
+        flags: "--name <name>",
+        description: "Channel name, with or without a leading '#'"
+      },
+      {
+        flags: "--description <description>",
+        description: "Optional channel description"
+      },
+      {
+        flags: "--private",
+        description: "Create a private channel instead of a public channel"
+      }
+    ]
+  },
+  async (ctx, opts) => {
+    const name = normalizeChannelName(opts.name);
+    if (!name) {
+      throw new CliError({
+        code: "INVALID_ARG",
+        message: "--name is required"
+      });
+    }
+    const agentContext = ctx.loadAgentContext();
+    const client = ctx.createApiClient(agentContext);
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(agentContext.agentId)}/channels`,
+      {
+        name,
+        description: opts.description,
+        visibility: opts.private ? "private" : "public"
+      }
+    );
+    if (!res.ok || !res.data) {
+      throw new CliError({
+        code: res.status >= 500 ? "SERVER_5XX" : "CREATE_FAILED",
+        message: res.error ?? `HTTP ${res.status}`
+      });
+    }
+    writeText(ctx.io, formatCreateChannelResult(res.data) + "\n");
+  }
+);
+function registerChannelCreateCommand(parent, runtimeOptions) {
+  registerCliCommand(parent, channelCreateCommand, runtimeOptions);
+}
+
 // src/commands/channel/update.ts
+init_esm_shims();
 function normalizeChannelName2(raw) {
   return (raw ?? "").trim().replace(/^#/, "");
 }
@@ -49034,7 +49310,12 @@ function registerChannelRemoveMemberCommand(parent, runtimeOptions) {
 // src/commands/channel/join.ts
 init_esm_shims();
 function formatJoinChannelResult(target) {
-  return `Joined ${target}. You can now send messages there and receive ordinary channel delivery.`;
+  return [
+    `Joined ${target}. You can now send messages there and receive ordinary channel delivery.`,
+    "Still arrives:",
+    "- Personal @mentions still reach you even if you later mute ordinary channel updates.",
+    "- Threads you started or follow stay followed even if you later mute this channel."
+  ].join("\n");
 }
 function formatAlreadyJoined(target) {
   return `Already joined ${target}.`;
@@ -49190,12 +49471,90 @@ function registerChannelUnmuteCommand(parent, runtimeOptions) {
 
 // src/commands/server/info.ts
 init_esm_shims();
+function parseNonNegativeInt(raw, name, fallback) {
+  if (raw === void 0) return fallback;
+  if (!/^\d+$/.test(raw)) {
+    throw new CliError({
+      code: "INVALID_ARG",
+      message: `${name} must be a non-negative integer`
+    });
+  }
+  return Number(raw);
+}
+function parsePositiveInt2(raw, name, fallback) {
+  const value = parseNonNegativeInt(raw, name, fallback);
+  if (value <= 0) {
+    throw new CliError({
+      code: "INVALID_ARG",
+      message: `${name} must be greater than 0`
+    });
+  }
+  return value;
+}
+function selectedSections(opts) {
+  const sections = [];
+  if (opts.channels) sections.push("channels");
+  if (opts.agents) sections.push("agents");
+  if (opts.humans) sections.push("humans");
+  return sections;
+}
+function hasListModifier(opts) {
+  return Boolean(opts.joined || opts.query !== void 0 || opts.limit !== void 0 || opts.offset !== void 0);
+}
+function includesQuery(row, query) {
+  const needle = query?.trim().toLowerCase();
+  if (!needle) return true;
+  const values = Object.values(row).filter((value) => typeof value === "string").map((value) => value.toLowerCase());
+  return values.some((value) => value.includes(needle));
+}
+function pageRows(rows, offset, limit) {
+  return rows.slice(offset, offset + limit);
+}
+function nextCommand(section, opts, offset, limit, total) {
+  const nextOffset = offset + limit;
+  if (nextOffset >= total) return void 0;
+  const parts = ["raft server info", `--${section}`, `--offset ${nextOffset}`, `--limit ${limit}`];
+  if (opts.query?.trim()) parts.push(`--query ${JSON.stringify(opts.query.trim())}`);
+  if (opts.joined) parts.push("--joined");
+  return parts.join(" ");
+}
 var serverInfoCommand = defineCommand(
   {
     name: "info",
-    description: "List channels, agents, and humans on the current server"
+    description: "Show bounded server facts; use --full for the legacy full inventory",
+    options: [
+      { flags: "--full", description: "Print the full channels, agents, humans, and runtime inventory" },
+      { flags: "--channels", description: "List visible channels only" },
+      { flags: "--agents", description: "List agents only" },
+      { flags: "--humans", description: "List humans only" },
+      { flags: "--joined", description: "With --channels, show only joined channels" },
+      { flags: "--query <text>", description: "Filter the selected list by visible text" },
+      { flags: "--limit <n>", description: "Maximum rows for list output (default: 50)" },
+      { flags: "--offset <n>", description: "Rows to skip for list output (default: 0)" }
+    ]
   },
-  async (ctx) => {
+  async (ctx, opts = {}) => {
+    const sections = selectedSections(opts);
+    if (opts.full && sections.length > 0) {
+      throw new CliError({
+        code: "INVALID_ARG",
+        message: "--full cannot be combined with --channels, --agents, or --humans"
+      });
+    }
+    if (sections.length === 0 && hasListModifier(opts)) {
+      throw new CliError({
+        code: "INVALID_ARG",
+        message: "--query, --limit, --offset, and --joined require --channels, --agents, or --humans"
+      });
+    }
+    if (opts.joined && sections.some((section) => section !== "channels")) {
+      throw new CliError({
+        code: "INVALID_ARG",
+        message: "--joined can only be used with --channels"
+      });
+    }
+    const limit = parsePositiveInt2(opts.limit, "--limit", 50);
+    const offset = parseNonNegativeInt(opts.offset, "--offset", 0);
     const agentContext = ctx.loadAgentContext();
     const client = ctx.createApiClient(agentContext);
     const res = await createAgentApiSurfaceClient(client).server.info();
@@ -49206,14 +49565,56 @@ var serverInfoCommand = defineCommand(
         message: res.error ?? `HTTP ${res.status}`
       });
     }
-    const data = res.data;
-    if (data?.runtimeContext) {
-      data.runtimeContext = {
-        ...data.runtimeContext,
-        workspacePath: data.runtimeContext.workspacePath ?? ctx.env.SLOCK_CURRENT_WORKSPACE_PATH ?? null
-      };
+    if (!res.data) {
+      throw new CliError({
+        code: "INVALID_JSON_RESPONSE",
+        message: "Agent API serverInfo returned an empty response body"
+      });
     }
-    writeText(ctx.io, formatServerInfo(data));
+    const data = {
+      ...res.data,
+      runtimeContext: {
+        ...res.data.runtimeContext,
+        workspacePath: res.data.runtimeContext.workspacePath ?? ctx.env.SLOCK_CURRENT_WORKSPACE_PATH ?? null
+      }
+    };
+    if (opts.full) {
+      writeText(ctx.io, formatServerInfo(data));
+      return;
+    }
+    if (sections.length === 0) {
+      writeText(ctx.io, formatServerSummary(data));
+      return;
+    }
+    const chunks = [];
+    for (const section of sections) {
+      if (section === "channels") {
+        const rows = (data.channels ?? []).filter((channel) => !opts.joined || channel.joined).filter((channel) => includesQuery(channel, opts.query));
+        chunks.push(formatServerChannels(pageRows(rows, offset, limit), {
+          total: rows.length,
+          offset,
+          limit,
+          nextCommand: nextCommand(section, opts, offset, limit, rows.length)
+        }));
+      } else if (section === "agents") {
+        const rows = (data.agents ?? []).filter((agent) => includesQuery(agent, opts.query));
+        chunks.push(formatServerAgents(pageRows(rows, offset, limit), {
+          total: rows.length,
+          offset,
+          limit,
+          nextCommand: nextCommand(section, opts, offset, limit, rows.length)
+        }));
+      } else {
+        const rows = (data.humans ?? []).filter((human) => includesQuery(human, opts.query));
+        chunks.push(formatServerHumans(pageRows(rows, offset, limit), {
+          total: rows.length,
+          offset,
+          limit,
+          nextCommand: nextCommand(section, opts, offset, limit, rows.length)
+        }));
+      }
+    }
+    writeText(ctx.io, chunks.join("\n"));
   }
 );
 function registerServerInfoCommand(parent, runtimeOptions) {
@@ -49553,6 +49954,100 @@ function registerServerUpdateCommand(parent, runtimeOptions) {
   registerCliCommand(parent, serverUpdateCommand, runtimeOptions);
 }
 
+// src/commands/user/info.ts
+init_esm_shims();
+function parseNonNegativeInt2(raw, name, fallback) {
+  if (raw === void 0) return fallback;
+  if (!/^\d+$/.test(raw)) {
+    throw new CliError({
+      code: "INVALID_ARG",
+      message: `${name} must be a non-negative integer`
+    });
+  }
+  return Number(raw);
+}
+function parsePositiveInt3(raw, name, fallback) {
+  const value = parseNonNegativeInt2(raw, name, fallback);
+  if (value <= 0) {
+    throw new CliError({
+      code: "INVALID_ARG",
+      message: `${name} must be greater than 0`
+    });
+  }
+  return value;
+}
+function normalizeUserName(target) {
+  const trimmed = target?.trim() ?? "";
+  const name = trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+  if (!name) {
+    throw new CliError({
+      code: "INVALID_ARG",
+      message: "user name is required"
+    });
+  }
+  return name;
+}
+var userInfoCommand = defineCommand(
+  {
+    name: "info",
+    description: "Show narrow visible facts for a human or agent and its visible channel memberships",
+    arguments: ["<name>"],
+    options: [
+      { flags: "--limit <n>", description: "Maximum visible channels to inspect (default: 50)" },
+      { flags: "--offset <n>", description: "Visible channels to skip before inspection (default: 0)" }
+    ]
+  },
+  async (ctx, target, opts = {}) => {
+    const name = normalizeUserName(target);
+    const limit = parsePositiveInt3(opts.limit, "--limit", 50);
+    const offset = parseNonNegativeInt2(opts.offset, "--offset", 0);
+    const agentContext = ctx.loadAgentContext();
+    const client = ctx.createApiClient(agentContext);
+    const agentApi = createAgentApiSurfaceClient(client);
+    const infoRes = await agentApi.server.info();
+    if (!infoRes.ok) {
+      throw new CliError({
+        code: infoRes.status >= 500 ? "SERVER_5XX" : "INFO_FAILED",
+        message: infoRes.error ?? `HTTP ${infoRes.status}`
+      });
+    }
+    const agent = (infoRes.data?.agents ?? []).find((candidate) => candidate.name === name);
+    const human = (infoRes.data?.humans ?? []).find((candidate) => candidate.name === name);
+    const user = agent ? { kind: "agent", value: agent } : human ? { kind: "human", value: human } : null;
+    if (!user) {
+      throw new CliError({
+        code: "NOT_FOUND",
+        message: `User not found or not visible: @${name}`,
+        suggestedNextAction: "Run `raft server info --agents --query <name>` or `raft server info --humans --query <name>` to inspect visible users."
+      });
+    }
+    const visibleChannels = infoRes.data?.channels ?? [];
+    const inspectedChannels = visibleChannels.slice(offset, offset + limit);
+    const memberships = [];
+    let skippedChannels = 0;
+    for (const channel of inspectedChannels) {
+      const membersRes = await agentApi.channels.members({ channel: `#${channel.name}` });
+      if (!membersRes.ok) {
+        skippedChannels += 1;
+        continue;
+      }
+      const agents = membersRes.data?.agents ?? [];
+      const humans = membersRes.data?.humans ?? [];
+      const found = user.kind === "agent" ? agents.some((candidate) => candidate.name === name) : humans.some((candidate) => candidate.name === name);
+      if (found) memberships.push(channel);
+    }
+    writeText(ctx.io, formatUserInfo(user, memberships, {
+      total: visibleChannels.length,
+      offset,
+      limit,
+      nextCommand: offset + limit < visibleChannels.length ? `raft user info @${name} --offset ${offset + limit} --limit ${limit}` : void 0
+    }, skippedChannels));
+  }
+);
+function registerUserInfoCommand(parent, runtimeOptions) {
+  registerCliCommand(parent, userInfoCommand, runtimeOptions);
+}
+
 // src/commands/knowledge/get.ts
 init_esm_shims();
 function formatKnowledgeStdout(content) {
@@ -49628,6 +50123,91 @@ function registerKnowledgeGetCommand(parent, runtimeOptions) {
   registerCliCommand(parent, knowledgeGetCommand, runtimeOptions);
 }
 
+// src/commands/knowledge/search.ts
+init_esm_shims();
+function formatKnowledgeSearchResults(results) {
+  return results.map((result2, index) => {
+    const firstScreen = result2.firstScreen.trim();
+    const body = firstScreen.split(/\r?\n/).filter(Boolean).map((line) => `   ${line}`).join("\n");
+    return `${index + 1}. ${result2.slug} \u2014 ${result2.title}${body ? `
+${body}` : ""}`;
+  }).join("\n\n") + "\n";
+}
+function toKnowledgeSearchErrorCode(errorCode2, status) {
+  switch (errorCode2) {
+    case "INVALID_JSON_RESPONSE":
+    case "SCOPE_DENIED":
+    case "knowledge_agent_missing":
+    case "knowledge_internal_error":
+    case "knowledge_not_found":
+    case "knowledge_query_invalid":
+    case "knowledge_reason_invalid":
+    case "knowledge_scope_invalid":
+    case "knowledge_source_invalid":
+    case "knowledge_trace_id_invalid":
+    case "knowledge_turn_id_invalid":
+    case "unsupported_capability":
+      return errorCode2;
+    default:
+      return status >= 500 ? "SERVER_5XX" : "KNOWLEDGE_SEARCH_FAILED";
+  }
+}
+var knowledgeSearchCommand = defineCommand(
+  {
+    name: "search",
+    description: "Search Raft Manual for Agents topics from the current server",
+    arguments: ["<keywords>"],
+    options: [
+      {
+        flags: "--scope <scope>",
+        description: "Optional search scope. Currently supports: recipes"
+      },
+      {
+        flags: "--reason <text>",
+        description: "Optional rationale for this search (>=12 chars when provided)"
+      },
+      {
+        flags: "--turn-id <id>",
+        description: "Optional turn id for correlation in the knowledge event"
+      },
+      {
+        flags: "--trace-id <id>",
+        description: "Optional trace id for correlation in the knowledge event"
+      }
+    ],
+    helpAfter: '\nExamples:\n  raft manual search "preview before merge" --scope recipes\n  raft manual get recipes/technique/preview-env\n'
+  },
+  async (ctx, keywords, opts) => {
+    const agentContext = ctx.loadAgentContext();
+    const client = ctx.createApiClient(agentContext);
+    const res = await createAgentApiSurfaceClient(client).knowledge.search({
+      query: keywords,
+      scope: opts.scope,
+      reason: opts.reason,
+      turn_id: opts.turnId,
+      trace_id: opts.traceId
+    });
+    if (!res.ok) {
+      throw new CliError({
+        code: toKnowledgeSearchErrorCode(res.errorCode, res.status),
+        message: res.error ?? `HTTP ${res.status}`,
+        suggestedNextAction: res.suggestedNextAction ?? (res.errorCode === "knowledge_not_found" ? "Try different keywords, or run `raft manual get index` to browse available topics." : void 0)
+      });
+    }
+    const data = res.data;
+    if (!data || data.ok !== true || !Array.isArray(data.results)) {
+      throw new CliError({
+        code: "KNOWLEDGE_SEARCH_FAILED",
+        message: "Server returned an unexpected response shape"
+      });
+    }
+    writeText(ctx.io, formatKnowledgeSearchResults(data.results));
+  }
+);
+function registerKnowledgeSearchCommand(parent, runtimeOptions) {
+  registerCliCommand(parent, knowledgeSearchCommand, runtimeOptions);
+}
+
 // src/commands/inbox/check.ts
 init_esm_shims();
 
@@ -49689,7 +50269,11 @@ function parseThreadTarget(target) {
   return null;
 }
 function formatUnfollowThreadResult(target) {
-  return `Unfollowed ${target}. You can still inspect the thread when its parent conversation is visible, but you will no longer receive ordinary thread delivery unless you follow it again or are mentioned.`;
+  return [
+    `Unfollowed ${target}. Ordinary delivery for this thread has stopped.`,
+    "Still arrives: personal @mentions pierce as single messages \u2014 they do NOT re-follow you.",
+    "Posting in this thread re-follows you automatically."
+  ].join("\n");
 }
 var threadUnfollowCommand = defineCommand(
   {
@@ -50342,6 +50926,168 @@ You can also choose not to send anything.
 `
   });
 }
+function formatDriveByJoinedToPostTip(target, data) {
+  const attention = data.attention?.driveByJoinedToPost;
+  if (!attention) return "";
+  const muteCommand = attention.muteCommand?.trim() || `raft channel mute "${target}"`;
+  const stillArrives = attention.stillArrives?.[0]?.trim() || "@mentions still reach you, and threads you started stay followed.";
+  return [
+    "Tip: you joined this channel to post this message. If you don't need its ordinary updates:",
+    `  ${muteCommand}`,
+    stillArrives
+  ].join("\n");
+}
+function markSendFailureDraftSaved(err, draftSaved) {
+  if (err instanceof CliError) {
+    if (err.draftSaved !== void 0) return err;
+    return new CliError({
+      code: err.code,
+      message: err.message,
+      exitCode: err.exitCode,
+      cause: err.cause,
+      suggestedNextAction: err.suggestedNextAction,
+      draftSaved
+    });
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return new CliError({
+    code: "INTERNAL_BUG",
+    message: `Unexpected error: ${message}`,
+    cause: err,
+    draftSaved
+  });
+}
+async function handleMessageSend(ctx, positionalContent, opts, setFailureDraftSaved) {
+  const target = opts.target?.trim() ?? "";
+  if (!target) {
+    throw cliError("INVALID_ARG", "--target is required");
+  }
+  try {
+    rejectArgContent(positionalContent, opts);
+  } catch (err) {
+    if (err instanceof SendContentError) throw cliError(err.code, err.message, { cause: err });
+    throw err;
+  }
+  try {
+    validateDraftSendFlags(opts);
+  } catch (err) {
+    if (err instanceof SendContentError) throw cliError(err.code, err.message, { cause: err });
+    throw err;
+  }
+  let content;
+  let outgoingContent = "";
+  let outgoingAttachmentIds = [];
+  let previousDraftReholdCount = 0;
+  let seenUpToSeq;
+  if (opts.sendDraft) {
+    content = await resolveOptionalSendContent(ctx.io.stdin ?? process.stdin);
+    try {
+      rejectSendDraftStdin(content, opts.target);
+    } catch (err) {
+      if (err instanceof SendContentError) throw cliError(err.code, err.message, { cause: err });
+      throw err;
+    }
+  } else {
+    try {
+      content = await resolveSendContent(ctx.io.stdin ?? process.stdin);
+    } catch (err) {
+      if (err instanceof SendContentError) throw cliError(err.code, err.message, { cause: err });
+      throw err;
+    }
+    outgoingContent = content;
+    outgoingAttachmentIds = opts.attachmentId && opts.attachmentId.length > 0 ? opts.attachmentId : [];
+  }
+  const agentContext = ctx.loadAgentContext();
+  const client = ctx.createApiClient(agentContext);
+  if (opts.sendDraft) {
+    const savedDraft = getSavedDraft(agentContext.agentId, target);
+    if (!savedDraft) {
+      throw cliError(
+        "SEND_DRAFT_NOT_FOUND",
+        [
+          "No saved draft exists for this target.",
+          "To create or update a draft, send message content normally:",
+          `  raft message send --target "${target}" <<'${MESSAGE_HEREDOC_DELIMITER}'`,
+          "  message body",
+          `  ${MESSAGE_HEREDOC_DELIMITER}`
+        ].join("\n")
+      );
+    }
+    outgoingContent = savedDraft.content;
+    outgoingAttachmentIds = savedDraft.attachmentIds;
+    previousDraftReholdCount = savedDraft.reholdCount;
+    seenUpToSeq = savedDraft.seenUpToSeq;
+    setFailureDraftSaved(true);
+  } else {
+    const previousDraft = getSavedDraft(agentContext.agentId, target);
+    previousDraftReholdCount = previousDraft?.reholdCount ?? 0;
+    seenUpToSeq = previousDraft?.seenUpToSeq;
+  }
+  if (seenUpToSeq === void 0) {
+    seenUpToSeq = getConsumedSeq(agentContext.agentId, target);
+  }
+  const body = {
+    target,
+    content: outgoingContent,
+    draftReholdCount: previousDraftReholdCount
+  };
+  if (seenUpToSeq !== void 0) {
+    body.seenUpToSeq = seenUpToSeq;
+  }
+  if (opts.sendDraft) {
+    body.sendDraft = true;
+    if (opts.anyway) body.continueAnyway = true;
+  } else {
+    body.draftReplacedExisting = previousDraftReholdCount > 0;
+  }
+  if (outgoingAttachmentIds.length > 0) {
+    body.attachmentIds = outgoingAttachmentIds;
+  }
+  const agentApi = createAgentApiSurfaceClient(client);
+  const res = await agentApi.messages.send(body);
+  if (!res.ok) {
+    const code = res.status >= 500 ? "SERVER_5XX" : "SEND_FAILED";
+    throw cliError(code, res.error ?? `HTTP ${res.status}`);
+  }
+  const data = res.data;
+  if (!data) {
+    throw cliError("INVALID_JSON_RESPONSE", "Agent API messageSend returned an empty response body");
+  }
+  if (data.state === "held") {
+    if (typeof data.seenUpToSeq === "number" && Number.isFinite(data.seenUpToSeq)) {
+      recordConsumedSeqs(agentContext.agentId, { [target]: data.seenUpToSeq });
+    }
+    setSavedDraft(agentContext.agentId, target, {
+      content: outgoingContent,
+      attachmentIds: outgoingAttachmentIds,
+      savedAt: Date.now(),
+      reholdCount: previousDraftReholdCount + 1,
+      seenUpToSeq: data.seenUpToSeq
+    });
+    writeText(ctx.io, formatHeldSendOutput(target, data));
+    return;
+  }
+  clearSavedDraft(agentContext.agentId, target);
+  const shortId = data.messageId ? data.messageId.slice(0, 8) : null;
+  const replyHint = shortId ? ` (to reply in this message's thread, use target "${target.includes(":") ? target : target + ":" + shortId}")` : "";
+  let unreadSection = "";
+  if (data.recentUnread && data.recentUnread.length > 0) {
+    unreadSection = `
+
+--- New messages you may have missed ---
+${formatMessages(data.recentUnread)}`;
+  }
+  const pendingMentionActions = normalizePendingMentionActions(data);
+  const mentionSection = pendingMentionActions.length > 0 ? `
+
+${formatPendingMentionActions(pendingMentionActions, { source: "send" }).trimEnd()}` : "";
+  const driveByTip = formatDriveByJoinedToPostTip(target, data);
+  const driveBySection = driveByTip ? `
+
+${driveByTip}` : "";
+  writeText(ctx.io, `Message sent to ${target}. Message ID: ${data.messageId}${replyHint}${driveBySection}${mentionSection}${unreadSection}
+`);
+}
 var messageSendCommand = defineCommand(
   {
     name: "send",
@@ -50360,131 +51106,14 @@ var messageSendCommand = defineCommand(
     ]
   },
   async (ctx, positionalContent, opts) => {
-    const target = opts.target?.trim() ?? "";
-    if (!target) {
-      throw cliError("INVALID_ARG", "--target is required");
-    }
-    try {
-      rejectArgContent(positionalContent, opts);
-    } catch (err) {
-      if (err instanceof SendContentError) throw cliError(err.code, err.message, { cause: err });
-      throw err;
-    }
+    let failureDraftSaved = false;
     try {
-      validateDraftSendFlags(opts);
-    } catch (err) {
-      if (err instanceof SendContentError) throw cliError(err.code, err.message, { cause: err });
-      throw err;
-    }
-    let content;
-    let outgoingContent = "";
-    let outgoingAttachmentIds = [];
-    let previousDraftReholdCount = 0;
-    let seenUpToSeq;
-    if (opts.sendDraft) {
-      content = await resolveOptionalSendContent(ctx.io.stdin ?? process.stdin);
-      try {
-        rejectSendDraftStdin(content, opts.target);
-      } catch (err) {
-        if (err instanceof SendContentError) throw cliError(err.code, err.message, { cause: err });
-        throw err;
-      }
-    } else {
-      try {
-        content = await resolveSendContent(ctx.io.stdin ?? process.stdin);
-      } catch (err) {
-        if (err instanceof SendContentError) throw cliError(err.code, err.message, { cause: err });
-        throw err;
-      }
-      outgoingContent = content;
-      outgoingAttachmentIds = opts.attachmentId && opts.attachmentId.length > 0 ? opts.attachmentId : [];
-    }
-    const agentContext = ctx.loadAgentContext();
-    const client = ctx.createApiClient(agentContext);
-    if (opts.sendDraft) {
-      const savedDraft = getSavedDraft(agentContext.agentId, target);
-      if (!savedDraft) {
-        throw cliError(
-          "SEND_DRAFT_NOT_FOUND",
-          [
-            "No saved draft exists for this target.",
-            "To create or update a draft, send message content normally:",
-            `  raft message send --target "${target}" <<'${MESSAGE_HEREDOC_DELIMITER}'`,
-            "  message body",
-            `  ${MESSAGE_HEREDOC_DELIMITER}`
-          ].join("\n")
-        );
-        return;
-      }
-      outgoingContent = savedDraft.content;
-      outgoingAttachmentIds = savedDraft.attachmentIds;
-      previousDraftReholdCount = savedDraft.reholdCount;
-      seenUpToSeq = savedDraft.seenUpToSeq;
-    } else {
-      const previousDraft = getSavedDraft(agentContext.agentId, target);
-      previousDraftReholdCount = previousDraft?.reholdCount ?? 0;
-      seenUpToSeq = previousDraft?.seenUpToSeq;
-    }
-    if (seenUpToSeq === void 0) {
-      seenUpToSeq = getConsumedSeq(agentContext.agentId, target);
-    }
-    const body = {
-      target,
-      content: outgoingContent,
-      draftReholdCount: previousDraftReholdCount
-    };
-    if (seenUpToSeq !== void 0) {
-      body.seenUpToSeq = seenUpToSeq;
-    }
-    if (opts.sendDraft) {
-      body.sendDraft = true;
-      if (opts.anyway) body.continueAnyway = true;
-    } else {
-      body.draftReplacedExisting = previousDraftReholdCount > 0;
-    }
-    if (outgoingAttachmentIds.length > 0) {
-      body.attachmentIds = outgoingAttachmentIds;
-    }
-    const agentApi = createAgentApiSurfaceClient(client);
-    const res = await agentApi.messages.send(body);
-    if (!res.ok) {
-      const code = res.status >= 500 ? "SERVER_5XX" : "SEND_FAILED";
-      throw cliError(code, res.error ?? `HTTP ${res.status}`);
-    }
-    const data = res.data;
-    if (!data) {
-      throw cliError("INVALID_JSON_RESPONSE", "Agent API messageSend returned an empty response body");
-    }
-    if (data.state === "held") {
-      if (typeof data.seenUpToSeq === "number" && Number.isFinite(data.seenUpToSeq)) {
-        recordConsumedSeqs(agentContext.agentId, { [target]: data.seenUpToSeq });
-      }
-      setSavedDraft(agentContext.agentId, target, {
-        content: outgoingContent,
-        attachmentIds: outgoingAttachmentIds,
-        savedAt: Date.now(),
-        reholdCount: previousDraftReholdCount + 1,
-        seenUpToSeq: data.seenUpToSeq
+      await handleMessageSend(ctx, positionalContent, opts, (draftSaved) => {
+        failureDraftSaved = draftSaved;
       });
-      writeText(ctx.io, formatHeldSendOutput(target, data));
-      return;
-    }
-    clearSavedDraft(agentContext.agentId, target);
-    const shortId = data.messageId ? data.messageId.slice(0, 8) : null;
-    const replyHint = shortId ? ` (to reply in this message's thread, use target "${target.includes(":") ? target : target + ":" + shortId}")` : "";
-    let unreadSection = "";
-    if (data.recentUnread && data.recentUnread.length > 0) {
-      unreadSection = `
-
---- New messages you may have missed ---
-${formatMessages(data.recentUnread)}`;
+    } catch (err) {
+      throw markSendFailureDraftSaved(err, failureDraftSaved);
     }
-    const pendingMentionActions = normalizePendingMentionActions(data);
-    const mentionSection = pendingMentionActions.length > 0 ? `
-
-${formatPendingMentionActions(pendingMentionActions, { source: "send" }).trimEnd()}` : "";
-    writeText(ctx.io, `Message sent to ${target}. Message ID: ${data.messageId}${replyHint}${mentionSection}${unreadSection}
-`);
   }
 );
 function registerSendCommand(parent, runtimeOptions = {}) {
@@ -50596,7 +51225,7 @@ function requireTargetAlias(opts) {
 }
 
 // src/commands/message/read.ts
-function parsePositiveInt2(name, raw) {
+function parsePositiveInt4(name, raw) {
   if (raw === void 0) return void 0;
   const n = Number(raw);
   if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
@@ -50635,7 +51264,7 @@ function mapReadFailure(res) {
 }
 function validateReadOpts(opts) {
   const channel = requireTargetAlias(opts);
-  const limit = parsePositiveInt2("limit", opts.limit);
+  const limit = parsePositiveInt4("limit", opts.limit);
   const before = opts.before?.trim();
   const after = opts.after?.trim();
   return {
@@ -50727,7 +51356,7 @@ function normalizeMemberHandleRef(raw) {
   }
   return handle;
 }
-function parsePositiveInt3(name, raw) {
+function parsePositiveInt5(name, raw) {
   if (raw === void 0) return void 0;
   const n = Number(raw);
   if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
@@ -50738,7 +51367,7 @@ function parsePositiveInt3(name, raw) {
   }
   return n;
 }
-function parseNonNegativeInt(name, raw) {
+function parseNonNegativeInt3(name, raw) {
   if (raw === void 0) return void 0;
   const n = Number(raw);
   if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0) {
@@ -50772,8 +51401,8 @@ function normalizeSearchOpts(opts) {
       message: "--sort relevance requires --query; filter-only search is sorted by recent"
     });
   }
-  const limit = parsePositiveInt3("limit", opts.limit);
-  const offset = parseNonNegativeInt("offset", opts.offset);
+  const limit = parsePositiveInt5("limit", opts.limit);
+  const offset = parseNonNegativeInt3("offset", opts.offset);
   const sort = opts.sort ?? (query ? void 0 : "recent");
   return {
     ...query ? { query } : {},
@@ -53737,6 +54366,7 @@ registerAgentLoginCommand(agentCmd);
 registerAgentListCommand(agentCmd);
 registerAgentBridgeCommand(agentCmd);
 var channelCmd = program2.command("channel").description("Channel membership and attention operations");
+registerChannelInfoCommand(channelCmd);
 registerChannelMembersCommand(channelCmd);
 registerChannelCreateCommand(channelCmd);
 registerChannelUpdateCommand(channelCmd);
@@ -53751,10 +54381,14 @@ registerThreadUnfollowCommand(threadCmd);
 var serverCmd = program2.command("server").description("Server / workspace introspection");
 registerServerInfoCommand(serverCmd);
 registerServerUpdateCommand(serverCmd);
+var userCmd = program2.command("user").description("User and agent introspection");
+registerUserInfoCommand(userCmd);
 var manualCmd = program2.command("manual").description("Raft Manual for Agents retrieval (canonical operating topics)");
 registerKnowledgeGetCommand(manualCmd);
+registerKnowledgeSearchCommand(manualCmd);
 var knowledgeCmd = program2.command("knowledge").description("Legacy alias for `raft manual`");
 registerKnowledgeGetCommand(knowledgeCmd);
+registerKnowledgeSearchCommand(knowledgeCmd);
 var inboxCmd = program2.command("inbox").description("Inbox target summary operations");
 registerInboxCheckCommand(inboxCmd);
 var messageCmd = program2.command("message").description("Message operations");