@hybridaione/hybridclaw 0.1.24 → 0.2.1

package/CHANGELOG.md

@@ -8,6 +8,46 @@
 
 ### Fixed
 
+## [0.2.1](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.1)
+
+### Added
+
+- **Discord `message` tool actions**: Added OpenClaw-style `message` tool support in the container with `read`, `member-info`, and `channel-info` actions, routed via the gateway API.
+- **Gateway Discord action endpoint**: Added `POST /api/discord/action` to execute Discord context actions for tools and automated runs.
+
+### Changed
+
+- **Discord presence handling**: Switched from prompt-injected presence snapshots to cache-backed presence data returned by `member-info` (`status` + `activities`) when available.
+- **Discord context guidance**: Updated safety prompt policy to explicitly route recap/member lookup questions through `message` tool actions instead of guessing.
+- **Tool allowlists**: Enabled `message` in heartbeat and base subagent allowed tool sets for delegated and automated workflows.
+- **Container gateway auth context**: Container input now carries gateway base URL/token and maps loopback hosts to `host.docker.internal` for in-container API reachability.
+- **Gateway token fallback**: Runtime now generates an internal gateway API token when no explicit token is configured, while preserving env/config overrides.
+
+### Fixed
+
+
+## [0.2.0](https://github.com/HybridAIOne/hybridclaw/tree/v0.2.0)
+
+### Added
+
+- **Personality switcher skill**: Added `skills/personality/SKILL.md` with `/personality` command workflow (`list`, `set`, `reset`) and a 25-profile persona set (including expert, style, and role personas like `pirate`, `noir`, `german`, `coach`, `doctor`, `soldier`, and `lawyer`).
+- **Ralph loop runtime mode**: Added configurable autonomous iteration (`proactive.ralph.maxIterations`) in the container tool loop. When enabled, turns continue automatically until the model emits `<choice>STOP</choice>` (or the configured loop budget is reached).
+- **Ralph command controls**: Added gateway/TUI command support for `ralph on|off|set <n>|info`, with immediate current-session container restart to apply loop settings without waiting for idle recycle.
+- **Skill creator authoring toolkit**: Added bundled `skills/skill-creator/` (invocable skill, references, and helper scripts) for initializing, validating, packaging, and generating `agents/openai.yaml` metadata for new skills.
+- **Discord context enrichment pipeline**: Added pending guild-history context, participant alias memory, `@name` mention-to-ID rewrite support, and optional per-channel presence snapshots for better grounded Discord replies.
+
+### Changed
+
+- **Personality persistence contract**: Standardized the managed `SOUL.md` personality block to `Name`, `Definition`, and `Rules`, so active persona behavior is fully file-driven.
+- **Personality style policy**: Updated persona rules so style signals are explicitly visible for the active personality (instead of only a subset).
+- **Personality skill prompt mode**: Set personality switching to command-only behavior (`always: false`, `disable-model-invocation: true`) to avoid per-turn prompt overhead while keeping `/personality` invocations available.
+- **Workspace AGENTS template behavior**: Updated `templates/AGENTS.md` group-chat guidance with explicit "Quality > quantity" speaking rules and emoji-reaction social-signal policy (`React Like a Human`, one reaction per message).
+- **Runtime self-awareness hook**: Prompt assembly now always injects runtime metadata (`version`, UTC date, model/default model, chatbot/channel/guild IDs, node/OS/host/workspace) and keeps it active in `minimal` mode.
+- **Discord runtime controls**: Added and hot-wired `discord.{guildMembersIntent,presenceIntent,respondToAllMessages,commandsOnly,commandUserId}` config behavior for intent selection, trigger policy, and command-user authorization.
+- **Gateway status reporting**: `status` command output now includes the running HybridClaw version line.
+
+### Fixed
+
 ## [0.1.24](https://github.com/HybridAIOne/hybridclaw/tree/v0.1.24)
 
 ### Added

package/README.md

@@ -11,7 +11,15 @@ npm install -g @hybridaione/hybridclaw
 hybridclaw onboarding
 ```
 
-Latest release: [v0.1.24](https://github.com/HybridAIOne/hybridclaw/releases/tag/v0.1.24)
+Latest release: [v0.2.1](https://github.com/HybridAIOne/hybridclaw/releases/tag/v0.2.1)
+
+## What's new in v0.2.1
+
+- Added OpenClaw-style Discord `message` tool actions (`read`, `member-info`, `channel-info`) to the container runtime
+- Added gateway endpoint `POST /api/discord/action` for Discord context lookups from tools
+- Replaced prompt-time Discord presence snapshots with cache-backed `member-info` presence fields (`status`, `activities`)
+- Routed Discord context lookups through gateway API from container with host remapping and token propagation
+- Enabled `message` tool in heartbeat and base subagent allowlists
 
 ## HybridAI Advantage
 
@@ -79,6 +87,7 @@ HybridClaw best-in-class capabilities:
 - formal prompt hook orchestration (`bootstrap`, `memory`, `safety`)
 - Discord conversational UX: edit-in-place streaming responses, fence-safe chunking beyond Discord's 2000-char limit, typing keepalive, debounce batching, reply-chain-aware context, and concise attachment-first screenshot replies
 - token-efficient context assembly: per-message history truncation, hard history budgets with head/tail preservation, and head/tail truncation for oversized bootstrap files
+- runtime self-awareness in prompts: exact HybridClaw version/date, model, and runtime host metadata injected each turn for reliable "what version/model are you?" answers
 - proactive runtime layer with active-hours gating, push delegation (`single`/`parallel`/`chain`), depth-aware tool policy, and retry controls
 - structured audit trail: append-only hash-chained wire logs (`data/audit/<session>/wire.jsonl`) with tamper-evident immutability, normalized SQLite audit tables, and verification/search CLI commands
 - observability export: incremental `events:batch` forwarding with durable cursor tracking and bot-scoped ingest token lifecycle via `ingest-token:ensure`
@@ -92,11 +101,18 @@ HybridClaw uses typed runtime config in `config.json` (auto-created on first run
 
 - Start from `config.example.json` (reference)
 - Runtime watches `config.json` and hot-reloads most settings (model defaults, heartbeat, prompt hooks, limits, etc.)
+- `discord.guildMembersIntent` enables richer guild member context and better `@name` mention resolution in replies (requires enabling **Server Members Intent** in Discord Developer Portal)
+- `discord.presenceIntent` enables Discord presence events (requires enabling **Presence Intent** in Discord Developer Portal)
+- `discord.respondToAllMessages` changes guild trigger behavior: `false` (default) replies only on mention/`!claw`; `true` replies to every user message in the channel
+- `discord.commandUserId` restricts `!claw <command>` admin commands to a single Discord user ID (all other messages still use normal chat handling)
+- `discord.commandsOnly` optional hard mode: if `true`, the bot ignores non-`!claw` messages and only accepts prefixed commands (optionally limited by `discord.commandUserId`)
 - `skills.extraDirs` adds additional enterprise/shared skill roots (lowest precedence tier)
-- `proactive.*` controls autonomous behavior (`activeHours`, `delegation`, `autoRetry`)
+- `proactive.*` controls autonomous behavior (`activeHours`, `delegation`, `autoRetry`, `ralph`)
+- `proactive.ralph.maxIterations` enables Ralph loop (`0` off, `-1` unlimited, `>0` extra autonomous iterations before forcing completion)
+- TUI/Gateway command: `ralph on|off|set <n>|info` (`0` off, `-1` unlimited, `1-64` extra iterations)
 - `observability.*` controls push ingest into HybridAI (`events:batch` endpoint, batching, identity metadata)
 - Some settings require restart to fully apply (for example HTTP bind host/port)
-- Default bot is configured via `hybridai.defaultChatbotId` in `config.json` (legacy `HYBRIDAI_CHATBOT_ID` values are auto-migrated on startup)
+- Default bot is configured via `hybridai.defaultChatbotId` in `config.json`
 
 Secrets remain in `.env`:
 
@@ -258,6 +274,29 @@ Explicit invocation is supported via:
 Example skill in this repo:
 
 - `skills/repo-orientation/SKILL.md`
+- `skills/current-time/SKILL.md`
+- `skills/personality/SKILL.md`
+- `skills/skill-creator/SKILL.md`
+
+### Personality switching skill
+
+HybridClaw includes a command-only personality skill that updates the active persona contract in `SOUL.md`.
+
+- List current/available persona: `/personality` (or `/personality list`)
+- Activate persona: `/personality <name>`
+- Reset to default persona: `/personality reset`
+
+The skill writes/updates a managed block in `SOUL.md`:
+
+- `## Active personality`
+- `Name: ...`
+- `Definition: ...` (copied from the selected profile in `skills/personality/SKILL.md`)
+- `Rules: ...` (runtime style/behavior constraints)
+
+Notes:
+
+- The personality skill is intentionally command-only (`always: false`, `disable-model-invocation: true`) to avoid adding per-turn prompt overhead.
+- Profiles are defined in `skills/personality/SKILL.md` and currently include 25 switchable personas (expert, style, and role personas).
 
 ## Agent tools
 
@@ -321,6 +360,7 @@ CLI runtime commands:
 - `hybridclaw gateway <command...>` — Send a command to a running gateway (for example `sessions`, `bot info`)
 - `hybridclaw tui` — Start terminal client connected to gateway
 - `hybridclaw onboarding` — Run HybridAI account/API key onboarding
+- `hybridclaw update [status|--check] [--yes]` — Check for updates and upgrade global npm installs (source checkouts get git-based update instructions)
 - `hybridclaw audit ...` — Verify and inspect structured audit trail (`recent`, `search`, `approvals`, `verify`, `instructions`)
 
 In Discord, use `!claw help` to see all commands. Key ones:

package/config.example.json

@@ -1,5 +1,5 @@
 {
-  "version": 2,
+  "version": 3,
   "security": {
     "trustModelAccepted": false,
     "trustModelAcceptedAt": "",
@@ -10,7 +10,12 @@
     "extraDirs": []
   },
   "discord": {
-    "prefix": "!claw"
+    "prefix": "!claw",
+    "guildMembersIntent": false,
+    "presenceIntent": false,
+    "respondToAllMessages": false,
+    "commandsOnly": false,
+    "commandUserId": ""
   },
   "hybridai": {
     "baseUrl": "https://hybridai.one",
@@ -94,6 +99,9 @@
       "maxAttempts": 3,
       "baseDelayMs": 2000,
       "maxDelayMs": 8000
+    },
+    "ralph": {
+      "maxIterations": 0
     }
   }
 }

package/container/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "hybridclaw-agent",
-  "version": "0.1.24",
+  "version": "0.2.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hybridclaw-agent",
-      "version": "0.1.24",
+      "version": "0.2.1",
       "dependencies": {
         "@mozilla/readability": "^0.6.0",
         "agent-browser": "^0.15.1",

package/container/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hybridclaw-agent",
-  "version": "0.1.24",
+  "version": "0.2.1",
   "type": "module",
   "scripts": {
     "build": "tsc",

package/container/src/index.ts

@@ -10,7 +10,16 @@ import {
   estimateTextTokens,
   finalizeTokenUsage,
 } from './token-usage.js';
-import { executeTool, getPendingSideEffects, resetSideEffects, setModelContext, setScheduledTasks, setSessionContext, TOOL_DEFINITIONS } from './tools.js';
+import {
+  executeTool,
+  getPendingSideEffects,
+  resetSideEffects,
+  setGatewayContext,
+  setModelContext,
+  setScheduledTasks,
+  setSessionContext,
+  TOOL_DEFINITIONS,
+} from './tools.js';
 import type { ArtifactMetadata, ChatMessage, ContainerInput, ContainerOutput, ToolDefinition, ToolExecution } from './types.js';
 
 const MAX_ITERATIONS = 20;
@@ -19,6 +28,13 @@ const RETRY_ENABLED = process.env.HYBRIDCLAW_RETRY_ENABLED !== 'false';
 const RETRY_MAX_ATTEMPTS = Math.max(1, parseInt(process.env.HYBRIDCLAW_RETRY_MAX_ATTEMPTS || '3', 10));
 const RETRY_BASE_DELAY_MS = Math.max(100, parseInt(process.env.HYBRIDCLAW_RETRY_BASE_DELAY_MS || '2000', 10));
 const RETRY_MAX_DELAY_MS = Math.max(RETRY_BASE_DELAY_MS, parseInt(process.env.HYBRIDCLAW_RETRY_MAX_DELAY_MS || '8000', 10));
+const RAW_RALPH_MAX_EXTRA_ITERATIONS = Number.parseInt(process.env.HYBRIDCLAW_RALPH_MAX_ITERATIONS || '0', 10);
+const RALPH_MAX_EXTRA_ITERATIONS = Number.isFinite(RAW_RALPH_MAX_EXTRA_ITERATIONS)
+  ? (RAW_RALPH_MAX_EXTRA_ITERATIONS === -1
+    ? -1
+    : Math.max(0, Math.min(64, RAW_RALPH_MAX_EXTRA_ITERATIONS)))
+  : 0;
+const RALPH_ENABLED = RALPH_MAX_EXTRA_ITERATIONS !== 0;
 const WORKSPACE_ROOT = '/workspace';
 const ARTIFACT_MIME_TYPES: Record<string, string> = {
   '.gif': 'image/gif',
@@ -84,6 +100,64 @@ function inferToolError(result: string, blockedReason: string | null): boolean {
   return /\b(error|failed|denied|forbidden|timed out|timeout|exception|invalid)\b/i.test(result);
 }
 
+function latestUserPrompt(messages: ChatMessage[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role !== 'user') continue;
+    const text = String(message.content || '').replace(/\s+/g, ' ').trim();
+    if (!text) continue;
+    return text.slice(0, 1_200);
+  }
+  return 'Continue the task';
+}
+
+function parseRalphChoice(content: string | null): 'CONTINUE' | 'STOP' | null {
+  if (!content) return null;
+  const re = /<choice>\s*([^<]*)\s*<\/choice>/gi;
+  let match: RegExpExecArray | null = null;
+  let lastChoice: string | null = null;
+  while (true) {
+    match = re.exec(content);
+    if (!match) break;
+    lastChoice = (match[1] || '').trim().toUpperCase();
+  }
+  if (lastChoice === 'CONTINUE' || lastChoice === 'STOP') return lastChoice;
+  return null;
+}
+
+function stripRalphChoiceTags(content: string | null): string | null {
+  if (content == null) return content;
+  const stripped = content
+    .replace(/<choice>\s*[^<]*\s*<\/choice>/gi, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+  return stripped || content;
+}
+
+function buildRalphPrompt(taskPrompt: string, missingChoice: boolean): string {
+  const punctuatedPrompt = /[.!?]$/.test(taskPrompt) ? taskPrompt : `${taskPrompt}.`;
+  const lines = [
+    `${punctuatedPrompt} (You are running in an automated loop where the same prompt is fed repeatedly. Only choose STOP when the task is fully complete. Including it will stop further iterations. If you are not 100% sure, choose CONTINUE.)`,
+    '',
+    'Available branches:',
+    '- CONTINUE',
+    '- STOP',
+    '',
+    'Reply with a choice using <choice>...</choice>.',
+  ];
+  if (missingChoice) {
+    lines.push('');
+    lines.push('Your last response did not include a valid choice. Include exactly one: CONTINUE or STOP.');
+  }
+  return lines.join('\n');
+}
+
+function resolveMaxModelTurns(): number {
+  if (!RALPH_ENABLED) return MAX_ITERATIONS;
+  if (RALPH_MAX_EXTRA_ITERATIONS < 0) return Number.MAX_SAFE_INTEGER;
+  return Math.max(MAX_ITERATIONS, RALPH_MAX_EXTRA_ITERATIONS + 1);
+}
+
 function inferMimeType(filePath: string): string {
   const ext = path.posix.extname(filePath).toLowerCase();
   return ARTIFACT_MIME_TYPES[ext] || 'application/octet-stream';
@@ -237,9 +311,12 @@ async function processRequest(
   const artifacts: ArtifactMetadata[] = [];
   const artifactPaths = new Set<string>();
   const tokenUsage = createTokenUsageStats();
+  const ralphSeedPrompt = RALPH_ENABLED ? latestUserPrompt(messages) : '';
+  const maxModelTurns = resolveMaxModelTurns();
+  let ralphExtraIterations = 0;
   let iterations = 0;
 
-  while (iterations < MAX_ITERATIONS) {
+  while (iterations < maxModelTurns) {
     iterations++;
     tokenUsage.modelCalls += 1;
     tokenUsage.estimatedPromptTokens += estimateMessageTokens(history);
@@ -305,9 +382,39 @@ async function processRequest(
 
     const toolCalls = choice.message.tool_calls || [];
     if (toolCalls.length === 0) {
+      if (RALPH_ENABLED) {
+        const branchChoice = parseRalphChoice(choice.message.content);
+        if (branchChoice === 'STOP') {
+          const completed: ContainerOutput = {
+            status: 'success',
+            result: stripRalphChoiceTags(choice.message.content),
+            toolsUsed: [...new Set(toolsUsed)],
+            ...(artifacts.length > 0 ? { artifacts } : {}),
+            toolExecutions,
+            tokenUsage: finalizeTokenUsage(tokenUsage),
+          };
+          await emitRuntimeEvent({ event: 'turn_end', status: completed.status, toolsUsed: completed.toolsUsed });
+          return completed;
+        }
+
+        const canContinue = RALPH_MAX_EXTRA_ITERATIONS < 0 || ralphExtraIterations < RALPH_MAX_EXTRA_ITERATIONS;
+        if (canContinue) {
+          ralphExtraIterations += 1;
+          history.push({
+            role: 'user',
+            content: buildRalphPrompt(ralphSeedPrompt, branchChoice == null),
+          });
+          console.error(
+            `[ralph] continue ${ralphExtraIterations}`
+            + (RALPH_MAX_EXTRA_ITERATIONS < 0 ? '' : `/${RALPH_MAX_EXTRA_ITERATIONS}`),
+          );
+          continue;
+        }
+      }
+
       const completed: ContainerOutput = {
         status: 'success',
-        result: choice.message.content,
+        result: stripRalphChoiceTags(choice.message.content),
         toolsUsed: [...new Set(toolsUsed)],
         ...(artifacts.length > 0 ? { artifacts } : {}),
         toolExecutions,
@@ -366,7 +473,7 @@ async function processRequest(
   const lastAssistant = history.filter((m) => m.role === 'assistant').pop();
   const completed: ContainerOutput = {
     status: 'success',
-    result: lastAssistant?.content || 'Max tool iterations reached.',
+    result: stripRalphChoiceTags(lastAssistant?.content || null) || 'Max tool iterations reached.',
     toolsUsed: [...new Set(toolsUsed)],
     ...(artifacts.length > 0 ? { artifacts } : {}),
     toolExecutions,
@@ -401,6 +508,7 @@ async function main(): Promise<void> {
   resetSideEffects();
   setScheduledTasks(firstInput.scheduledTasks);
   setSessionContext(firstInput.sessionId);
+  setGatewayContext(firstInput.gatewayBaseUrl, firstInput.gatewayApiToken, firstInput.channelId);
   setModelContext(firstInput.baseUrl, storedApiKey, firstInput.model, firstInput.chatbotId);
 
   const firstOutput = await processRequest(
@@ -434,6 +542,7 @@ async function main(): Promise<void> {
     resetSideEffects();
     setScheduledTasks(input.scheduledTasks);
     setSessionContext(input.sessionId);
+    setGatewayContext(input.gatewayBaseUrl, input.gatewayApiToken, input.channelId);
     setModelContext(input.baseUrl, apiKey, input.model, input.chatbotId);
 
     const output = await processRequest(

package/container/src/tools.ts

@@ -47,9 +47,14 @@ let pendingSchedules: ScheduleSideEffect[] = [];
 let pendingDelegations: DelegationSideEffect[] = [];
 let injectedTasks: ScheduledTaskInfo[] = [];
 let currentSessionId = '';
+let gatewayBaseUrl = '';
+let gatewayApiToken = '';
+let gatewayChannelId = '';
 const MAX_PENDING_DELEGATIONS = 3;
 const MAX_DELEGATION_BATCH_ITEMS = 6;
 
+type DiscordMessageToolAction = 'read' | 'member-info' | 'channel-info';
+
 export function resetSideEffects(): void {
   pendingSchedules = [];
   pendingDelegations = [];
@@ -74,6 +79,12 @@ export function setSessionContext(sessionId: string): void {
   currentSessionId = String(sessionId || '');
 }
 
+export function setGatewayContext(baseUrl?: string, apiToken?: string, channelId?: string): void {
+  gatewayBaseUrl = String(baseUrl || '').trim();
+  gatewayApiToken = String(apiToken || '').trim();
+  gatewayChannelId = String(channelId || '').trim();
+}
+
 export function setModelContext(
   baseUrl: string,
   apiKey: string,
@@ -83,6 +94,73 @@ export function setModelContext(
   setBrowserModelContext(baseUrl, apiKey, model, chatbotId);
 }
 
+function readStringValue(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function resolveDiscordMessageAction(rawAction: unknown): DiscordMessageToolAction | null {
+  const normalized = readStringValue(rawAction)?.toLowerCase();
+  if (!normalized) return null;
+  if (normalized === 'read' || normalized === 'readmessages') return 'read';
+  if (normalized === 'member-info' || normalized === 'memberinfo') return 'member-info';
+  if (normalized === 'channel-info' || normalized === 'channelinfo') return 'channel-info';
+  return null;
+}
+
+function resolveGatewayDiscordActionUrl(): string | null {
+  const base = gatewayBaseUrl.replace(/\/+$/, '');
+  if (!base) return null;
+  return `${base}/api/discord/action`;
+}
+
+async function callGatewayDiscordAction(payload: Record<string, unknown>): Promise<string> {
+  const url = resolveGatewayDiscordActionUrl();
+  if (!url) {
+    return 'Error: Discord actions are unavailable because gatewayBaseUrl is not configured.';
+  }
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+  if (gatewayApiToken) {
+    headers.Authorization = `Bearer ${gatewayApiToken}`;
+  }
+
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(payload),
+    });
+  } catch (err) {
+    return `Error: Discord action request failed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+
+  const rawText = await response.text();
+  let parsed: Record<string, unknown> | null = null;
+  try {
+    const maybe = JSON.parse(rawText) as unknown;
+    if (maybe && typeof maybe === 'object' && !Array.isArray(maybe)) {
+      parsed = maybe as Record<string, unknown>;
+    }
+  } catch {
+    parsed = null;
+  }
+
+  if (!response.ok) {
+    const detail = typeof parsed?.error === 'string'
+      ? parsed.error
+      : rawText || `HTTP ${response.status}`;
+    return `Error: Discord action failed (${response.status}): ${detail}`;
+  }
+
+  if (parsed) return JSON.stringify(parsed, null, 2);
+  return rawText || JSON.stringify({ ok: true }, null, 2);
+}
+
 function normalizeDelegationTask(raw: unknown, fallbackModel?: string): DelegationTaskSpec | null {
   if (typeof raw === 'string') {
     const prompt = raw.trim();
@@ -802,6 +880,68 @@ export async function executeTool(name: string, argsJson: string): Promise<strin
         return `Error: unknown memory action "${action}". Use read, append, write, replace, remove, list, or search.`;
       }
 
+      case 'message': {
+        const action = resolveDiscordMessageAction(args.action);
+        if (!action) {
+          return 'Error: unsupported message action. Use "read", "member-info", or "channel-info".';
+        }
+
+        const payload: Record<string, unknown> = { action };
+
+        if (action === 'read') {
+          const channelId =
+            readStringValue(args.channelId)
+            || readStringValue(args.to)
+            || readStringValue(args.target)
+            || gatewayChannelId;
+          if (!channelId) {
+            return 'Error: channelId is required for message action "read".';
+          }
+          payload.channelId = channelId;
+
+          if (typeof args.limit === 'number' && Number.isFinite(args.limit)) {
+            payload.limit = Math.max(1, Math.min(100, Math.floor(args.limit)));
+          }
+          const before = readStringValue(args.before);
+          const after = readStringValue(args.after);
+          const around = readStringValue(args.around);
+          if (before) payload.before = before;
+          if (after) payload.after = after;
+          if (around) payload.around = around;
+        }
+
+        if (action === 'member-info') {
+          const guildId = readStringValue(args.guildId);
+          const userId =
+            readStringValue(args.userId)
+            || readStringValue(args.memberId)
+            || readStringValue(args.user)
+            || readStringValue(args.username);
+          if (!guildId) {
+            return 'Error: guildId is required for message action "member-info".';
+          }
+          if (!userId) {
+            return 'Error: userId/username is required for message action "member-info".';
+          }
+          payload.guildId = guildId;
+          payload.userId = userId;
+        }
+
+        if (action === 'channel-info') {
+          const channelId =
+            readStringValue(args.channelId)
+            || readStringValue(args.to)
+            || readStringValue(args.target)
+            || gatewayChannelId;
+          if (!channelId) {
+            return 'Error: channelId is required for message action "channel-info".';
+          }
+          payload.channelId = channelId;
+        }
+
+        return await callGatewayDiscordAction(payload);
+      }
+
       case 'session_search': {
         const query = typeof args.query === 'string' ? args.query.trim() : '';
         if (!query) return 'Error: query is required for session_search';
@@ -1191,6 +1331,58 @@ export const TOOL_DEFINITIONS: ToolDefinition[] = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'message',
+      description:
+        'OpenClaw-style channel action tool. In Discord-backed sessions supports actions: read, member-info, channel-info.',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: {
+            type: 'string',
+            description: 'Action to perform: "read", "member-info", or "channel-info".',
+            enum: ['read', 'member-info', 'channel-info'],
+          },
+          channelId: {
+            type: 'string',
+            description: 'Discord channel id. Defaults to current channel for read/channel-info.',
+          },
+          guildId: {
+            type: 'string',
+            description: 'Discord guild id (required for member-info).',
+          },
+          userId: {
+            type: 'string',
+            description: 'Discord user id (required for member-info).',
+          },
+          memberId: {
+            type: 'string',
+            description: 'Alias for userId in member-info.',
+          },
+          username: {
+            type: 'string',
+            description: 'Discord username/display name/@handle to resolve for member-info.',
+          },
+          user: {
+            type: 'string',
+            description: 'Alias for username/userId in member-info.',
+          },
+          limit: {
+            type: 'number',
+            description: 'Read limit for action="read" (default 20, max 100).',
+          },
+          before: { type: 'string', description: 'Read messages before this message id.' },
+          after: { type: 'string', description: 'Read messages after this message id.' },
+          around: { type: 'string', description: 'Read messages around this message id.' },
+          target: { type: 'string', description: 'Alias for channelId.' },
+          to: { type: 'string', description: 'Alias for channelId.' },
+        },
+        required: ['action'],
+      },
+    },
+  },
   {
     type: 'function',
     function: {

package/container/src/types.ts

@@ -67,6 +67,8 @@ export interface ContainerInput {
   enableRag: boolean;
   apiKey: string;
   baseUrl: string;
+  gatewayBaseUrl?: string;
+  gatewayApiToken?: string;
   model: string;
   channelId: string;
   scheduledTasks?: { id: number; cronExpr: string; runAt: string | null; everyMs: number | null; prompt: string; enabled: number; lastRun: string | null; createdAt: string }[];

package/dist/cli.js

@@ -4,7 +4,8 @@ import path from 'path';
 import { spawn, spawnSync } from 'child_process';
 import readline from 'readline/promises';
 import { ensureHybridAICredentials } from './onboarding.js';
-import { DATA_DIR, GATEWAY_BASE_URL, MissingRequiredEnvVarError } from './config.js';
+import { APP_VERSION, DATA_DIR, GATEWAY_BASE_URL, MissingRequiredEnvVarError } from './config.js';
+import { printUpdateUsage, runUpdateCommand } from './update.js';
 async function ensureRuntimeContainer(commandName, required = true) {
     const { ensureContainerImageReady } = await import('./container-setup.js');
     await ensureContainerImageReady({
@@ -152,6 +153,7 @@ function printMainUsage() {
   gateway    Manage core runtime (start/stop/status) or run gateway commands
   tui        Start terminal adapter (starts gateway automatically when needed)
   onboarding Run HybridAI account/API key onboarding
+  update     Check and apply HybridClaw CLI updates
   audit      Inspect/verify structured audit trail
   help       Show general or topic-specific help (e.g. \`hybridclaw help gateway\`)`);
 }
@@ -205,6 +207,7 @@ Topics:
   gateway     Help for gateway lifecycle and passthrough commands
   tui         Help for terminal client
   onboarding  Help for onboarding flow
+  update      Help for checking/applying CLI updates
   audit       Help for audit commands
   help        This help`);
 }
@@ -225,6 +228,9 @@ function printHelpTopic(topic) {
         case 'onboarding':
             printOnboardingUsage();
             return true;
+        case 'update':
+            printUpdateUsage();
+            return true;
         case 'audit':
             printAuditUsage();
             return true;
@@ -639,6 +645,14 @@ async function main() {
             await ensureHybridAICredentials({ force: true, commandName: 'hybridclaw onboarding' });
             await ensureRuntimeContainer('hybridclaw onboarding', false);
             break;
+        case 'update': {
+            if (isHelpRequest(subargs)) {
+                printUpdateUsage();
+                break;
+            }
+            await runUpdateCommand(subargs, APP_VERSION);
+            break;
+        }
         case 'audit': {
             if (isHelpRequest(subargs)) {
                 printAuditUsage();