@hybridaione/hybridclaw 0.2.3 → 0.2.7

package/src/config.ts

@@ -1,7 +1,8 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { randomBytes } from 'crypto';
+import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 import { loadEnvFile } from './env.js';
 import {
@@ -27,13 +28,9 @@ function required(name: string): string {
   return val;
 }
 
-function resolveAppVersion(): string {
-  const envVersion = process.env.npm_package_version;
-  if (envVersion) return envVersion;
-
-  const packagePath = path.join(process.cwd(), 'package.json');
+function readVersionFromPackageJson(packageJsonPath: string): string | null {
   try {
-    const raw = fs.readFileSync(packagePath, 'utf-8');
+    const raw = fs.readFileSync(packageJsonPath, 'utf-8');
     const parsed = JSON.parse(raw) as { version?: unknown };
     if (typeof parsed.version === 'string' && parsed.version.trim()) {
       return parsed.version.trim();
@@ -41,6 +38,31 @@ function resolveAppVersion(): string {
   } catch {
     // fall through
   }
+  return null;
+}
+
+function resolveAppVersion(): string {
+  const envVersion = process.env.npm_package_version;
+  if (envVersion?.trim()) return envVersion.trim();
+
+  const modulePath = fileURLToPath(import.meta.url);
+  const moduleVersion = readVersionFromPackageJson(
+    path.join(path.dirname(modulePath), '..', 'package.json'),
+  );
+  if (moduleVersion) return moduleVersion;
+
+  const entryPath = process.argv[1];
+  if (entryPath) {
+    const entryVersion = readVersionFromPackageJson(
+      path.join(path.dirname(path.resolve(entryPath)), '..', 'package.json'),
+    );
+    if (entryVersion) return entryVersion;
+  }
+
+  const cwdVersion = readVersionFromPackageJson(
+    path.join(process.cwd(), 'package.json'),
+  );
+  if (cwdVersion) return cwdVersion;
 
   return '0.0.0';
 }
@@ -61,14 +83,63 @@ export let DISCORD_GUILD_MEMBERS_INTENT = false;
 export let DISCORD_PRESENCE_INTENT = false;
 export let DISCORD_RESPOND_TO_ALL_MESSAGES = false;
 export let DISCORD_COMMANDS_ONLY = false;
+export let DISCORD_COMMAND_MODE: RuntimeConfig['discord']['commandMode'] =
+  'public';
+export let DISCORD_COMMAND_ALLOWED_USER_IDS: string[] = [];
 export let DISCORD_COMMAND_USER_ID = '';
-export let DISCORD_GROUP_POLICY: RuntimeConfig['discord']['groupPolicy'] = 'open';
+export let DISCORD_GROUP_POLICY: RuntimeConfig['discord']['groupPolicy'] =
+  'open';
 export let DISCORD_FREE_RESPONSE_CHANNELS: string[] = [];
+export let DISCORD_TEXT_CHUNK_LIMIT = 2_000;
+export let DISCORD_MAX_LINES_PER_MESSAGE = 17;
+export let DISCORD_HUMAN_DELAY: RuntimeConfig['discord']['humanDelay'] = {
+  mode: 'natural',
+  minMs: 800,
+  maxMs: 2_500,
+};
+export let DISCORD_TYPING_MODE: RuntimeConfig['discord']['typingMode'] =
+  'thinking';
+export let DISCORD_SELF_PRESENCE: RuntimeConfig['discord']['presence'] = {
+  enabled: true,
+  intervalMs: 30_000,
+  healthyText: 'Watching the channels',
+  degradedText: 'Thinking slowly...',
+  exhaustedText: 'Taking a break',
+  activityType: 'watching',
+};
+export let DISCORD_LIFECYCLE_REACTIONS: RuntimeConfig['discord']['lifecycleReactions'] =
+  {
+    enabled: true,
+    removeOnComplete: true,
+    phases: {
+      queued: '⏳',
+      thinking: '🤔',
+      toolUse: '⚙️',
+      streaming: '✍️',
+      done: '✅',
+      error: '❌',
+    },
+  };
+export let DISCORD_ACK_REACTION = '👀';
+export let DISCORD_ACK_REACTION_SCOPE: RuntimeConfig['discord']['ackReactionScope'] =
+  'group-mentions';
+export let DISCORD_REMOVE_ACK_AFTER_REPLY = true;
+export let DISCORD_DEBOUNCE_MS = 2_500;
+export let DISCORD_RATE_LIMIT_PER_USER = 0;
+export let DISCORD_RATE_LIMIT_EXEMPT_ROLES: string[] = [];
+export let DISCORD_SUPPRESS_PATTERNS: string[] = [
+  '/stop',
+  '/pause',
+  'brb',
+  'afk',
+];
+export let DISCORD_MAX_CONCURRENT_PER_CHANNEL = 2;
 export let DISCORD_GUILDS: RuntimeConfig['discord']['guilds'] = {};
 
 export let HYBRIDAI_BASE_URL = 'https://hybridai.one';
 export let HYBRIDAI_MODEL = 'gpt-5-nano';
 export let HYBRIDAI_CHATBOT_ID = '';
+export let HYBRIDAI_MAX_TOKENS = 4_096;
 export let HYBRIDAI_ENABLE_RAG = true;
 export let HYBRIDAI_MODELS: string[] = ['gpt-5-nano', 'gpt-5-mini', 'gpt-5'];
 
@@ -78,7 +149,10 @@ export let CONTAINER_CPUS = '1';
 export let CONTAINER_TIMEOUT = 300_000;
 
 export const MOUNT_ALLOWLIST_PATH = path.join(
-  os.homedir(), '.config', 'hybridclaw', 'mount-allowlist.json',
+  os.homedir(),
+  '.config',
+  'hybridclaw',
+  'mount-allowlist.json',
 );
 export let ADDITIONAL_MOUNTS = '';
 
@@ -88,6 +162,8 @@ export let MAX_CONCURRENT_CONTAINERS = 5;
 export let HEARTBEAT_ENABLED = true;
 export let HEARTBEAT_INTERVAL = 1_800_000;
 export let HEARTBEAT_CHANNEL = '';
+export let MEMORY_DECAY_RATE = 0.1;
+export let MEMORY_CONSOLIDATION_INTERVAL_HOURS = 24;
 
 export let HEALTH_HOST = '127.0.0.1';
 export let HEALTH_PORT = 9090;
@@ -100,7 +176,8 @@ export let DATA_DIR = path.dirname(DB_PATH);
 
 export let OBSERVABILITY_ENABLED = true;
 export let OBSERVABILITY_BASE_URL = 'https://hybridai.one';
-export let OBSERVABILITY_INGEST_PATH = '/api/v1/agent-observability/events:batch';
+export let OBSERVABILITY_INGEST_PATH =
+  '/api/v1/agent-observability/events:batch';
 export let OBSERVABILITY_STATUS_PATH = '/api/v1/agent-observability/status';
 export let OBSERVABILITY_BOT_ID = '';
 export let OBSERVABILITY_AGENT_ID = 'agent_main';
@@ -110,7 +187,9 @@ export let OBSERVABILITY_FLUSH_INTERVAL_MS = 10_000;
 export let OBSERVABILITY_BATCH_MAX_EVENTS = 500;
 
 export let SESSION_COMPACTION_ENABLED = true;
-export let SESSION_COMPACTION_THRESHOLD = 120;
+export let SESSION_COMPACTION_TOKEN_BUDGET = 100_000;
+export let SESSION_COMPACTION_BUDGET_RATIO = 0.7;
+export let SESSION_COMPACTION_THRESHOLD = 200;
 export let SESSION_COMPACTION_KEEP_RECENT = 40;
 export let SESSION_COMPACTION_SUMMARY_MAX_CHARS = 8_000;
 export let PRE_COMPACTION_MEMORY_FLUSH_ENABLED = true;
@@ -140,14 +219,51 @@ function applyRuntimeConfig(config: RuntimeConfig): void {
   DISCORD_PRESENCE_INTENT = config.discord.presenceIntent;
   DISCORD_RESPOND_TO_ALL_MESSAGES = config.discord.respondToAllMessages;
   DISCORD_COMMANDS_ONLY = config.discord.commandsOnly;
+  DISCORD_COMMAND_MODE = config.discord.commandMode;
+  DISCORD_COMMAND_ALLOWED_USER_IDS = [...config.discord.commandAllowedUserIds];
   DISCORD_COMMAND_USER_ID = config.discord.commandUserId;
   DISCORD_GROUP_POLICY = config.discord.groupPolicy;
   DISCORD_FREE_RESPONSE_CHANNELS = [...config.discord.freeResponseChannels];
-  DISCORD_GUILDS = JSON.parse(JSON.stringify(config.discord.guilds)) as RuntimeConfig['discord']['guilds'];
+  DISCORD_TEXT_CHUNK_LIMIT = Math.max(
+    200,
+    Math.min(2_000, config.discord.textChunkLimit),
+  );
+  DISCORD_MAX_LINES_PER_MESSAGE = Math.max(
+    4,
+    Math.min(200, config.discord.maxLinesPerMessage),
+  );
+  DISCORD_HUMAN_DELAY = JSON.parse(
+    JSON.stringify(config.discord.humanDelay),
+  ) as RuntimeConfig['discord']['humanDelay'];
+  DISCORD_TYPING_MODE = config.discord.typingMode;
+  DISCORD_SELF_PRESENCE = JSON.parse(
+    JSON.stringify(config.discord.presence),
+  ) as RuntimeConfig['discord']['presence'];
+  DISCORD_LIFECYCLE_REACTIONS = JSON.parse(
+    JSON.stringify(config.discord.lifecycleReactions),
+  ) as RuntimeConfig['discord']['lifecycleReactions'];
+  DISCORD_ACK_REACTION = config.discord.ackReaction;
+  DISCORD_ACK_REACTION_SCOPE = config.discord.ackReactionScope;
+  DISCORD_REMOVE_ACK_AFTER_REPLY = config.discord.removeAckAfterReply;
+  DISCORD_DEBOUNCE_MS = Math.max(0, config.discord.debounceMs);
+  DISCORD_RATE_LIMIT_PER_USER = Math.max(0, config.discord.rateLimitPerUser);
+  DISCORD_RATE_LIMIT_EXEMPT_ROLES = [...config.discord.rateLimitExemptRoles];
+  DISCORD_SUPPRESS_PATTERNS = [...config.discord.suppressPatterns];
+  DISCORD_MAX_CONCURRENT_PER_CHANNEL = Math.max(
+    1,
+    config.discord.maxConcurrentPerChannel,
+  );
+  DISCORD_GUILDS = JSON.parse(
+    JSON.stringify(config.discord.guilds),
+  ) as RuntimeConfig['discord']['guilds'];
 
   HYBRIDAI_BASE_URL = config.hybridai.baseUrl;
   HYBRIDAI_MODEL = config.hybridai.defaultModel;
   HYBRIDAI_CHATBOT_ID = config.hybridai.defaultChatbotId;
+  HYBRIDAI_MAX_TOKENS = Math.max(
+    256,
+    Math.min(32_768, config.hybridai.maxTokens),
+  );
   HYBRIDAI_ENABLE_RAG = config.hybridai.enableRag;
   HYBRIDAI_MODELS = [...config.hybridai.models];
 
@@ -162,16 +278,19 @@ function applyRuntimeConfig(config: RuntimeConfig): void {
   HEARTBEAT_ENABLED = config.heartbeat.enabled;
   HEARTBEAT_INTERVAL = config.heartbeat.intervalMs;
   HEARTBEAT_CHANNEL = config.heartbeat.channel;
+  MEMORY_DECAY_RATE = config.memory.decayRate;
+  MEMORY_CONSOLIDATION_INTERVAL_HOURS =
+    config.memory.consolidationIntervalHours;
 
   HEALTH_HOST = config.ops.healthHost;
   HEALTH_PORT = config.ops.healthPort;
   WEB_API_TOKEN = process.env.WEB_API_TOKEN || config.ops.webApiToken;
   GATEWAY_BASE_URL = config.ops.gatewayBaseUrl;
   GATEWAY_API_TOKEN =
-    process.env.GATEWAY_API_TOKEN
-    || config.ops.gatewayApiToken
-    || WEB_API_TOKEN
-    || INTERNAL_GATEWAY_API_TOKEN;
+    process.env.GATEWAY_API_TOKEN ||
+    config.ops.gatewayApiToken ||
+    WEB_API_TOKEN ||
+    INTERNAL_GATEWAY_API_TOKEN;
   DB_PATH = config.ops.dbPath;
   DATA_DIR = path.dirname(DB_PATH);
 
@@ -183,41 +302,94 @@ function applyRuntimeConfig(config: RuntimeConfig): void {
   OBSERVABILITY_AGENT_ID = config.observability.agentId;
   OBSERVABILITY_LABEL = config.observability.label;
   OBSERVABILITY_ENVIRONMENT = config.observability.environment;
-  OBSERVABILITY_FLUSH_INTERVAL_MS = Math.max(1_000, config.observability.flushIntervalMs);
-  OBSERVABILITY_BATCH_MAX_EVENTS = Math.max(1, Math.min(1_000, config.observability.batchMaxEvents));
+  OBSERVABILITY_FLUSH_INTERVAL_MS = Math.max(
+    1_000,
+    config.observability.flushIntervalMs,
+  );
+  OBSERVABILITY_BATCH_MAX_EVENTS = Math.max(
+    1,
+    Math.min(1_000, config.observability.batchMaxEvents),
+  );
 
   SESSION_COMPACTION_ENABLED = config.sessionCompaction.enabled;
-  SESSION_COMPACTION_THRESHOLD = Math.max(20, config.sessionCompaction.threshold);
+  SESSION_COMPACTION_TOKEN_BUDGET = Math.max(
+    1_000,
+    config.sessionCompaction.tokenBudget,
+  );
+  SESSION_COMPACTION_BUDGET_RATIO = Math.max(
+    0.05,
+    Math.min(1, config.sessionCompaction.budgetRatio),
+  );
+  SESSION_COMPACTION_THRESHOLD = Math.max(
+    20,
+    config.sessionCompaction.threshold,
+  );
   SESSION_COMPACTION_KEEP_RECENT = Math.max(
     1,
-    Math.min(config.sessionCompaction.keepRecent, SESSION_COMPACTION_THRESHOLD - 1),
+    Math.min(
+      config.sessionCompaction.keepRecent,
+      SESSION_COMPACTION_THRESHOLD - 1,
+    ),
+  );
+  SESSION_COMPACTION_SUMMARY_MAX_CHARS = Math.max(
+    1_000,
+    config.sessionCompaction.summaryMaxChars,
+  );
+  PRE_COMPACTION_MEMORY_FLUSH_ENABLED =
+    config.sessionCompaction.preCompactionMemoryFlush.enabled;
+  PRE_COMPACTION_MEMORY_FLUSH_MAX_MESSAGES = Math.max(
+    8,
+    config.sessionCompaction.preCompactionMemoryFlush.maxMessages,
+  );
+  PRE_COMPACTION_MEMORY_FLUSH_MAX_CHARS = Math.max(
+    4_000,
+    config.sessionCompaction.preCompactionMemoryFlush.maxChars,
   );
-  SESSION_COMPACTION_SUMMARY_MAX_CHARS = Math.max(1_000, config.sessionCompaction.summaryMaxChars);
-  PRE_COMPACTION_MEMORY_FLUSH_ENABLED = config.sessionCompaction.preCompactionMemoryFlush.enabled;
-  PRE_COMPACTION_MEMORY_FLUSH_MAX_MESSAGES = Math.max(8, config.sessionCompaction.preCompactionMemoryFlush.maxMessages);
-  PRE_COMPACTION_MEMORY_FLUSH_MAX_CHARS = Math.max(4_000, config.sessionCompaction.preCompactionMemoryFlush.maxChars);
 
   PROACTIVE_ACTIVE_HOURS_ENABLED = config.proactive.activeHours.enabled;
   PROACTIVE_ACTIVE_HOURS_TIMEZONE = config.proactive.activeHours.timezone;
-  PROACTIVE_ACTIVE_HOURS_START = Math.max(0, Math.min(23, config.proactive.activeHours.startHour));
-  PROACTIVE_ACTIVE_HOURS_END = Math.max(0, Math.min(23, config.proactive.activeHours.endHour));
-  PROACTIVE_QUEUE_OUTSIDE_HOURS = config.proactive.activeHours.queueOutsideHours;
+  PROACTIVE_ACTIVE_HOURS_START = Math.max(
+    0,
+    Math.min(23, config.proactive.activeHours.startHour),
+  );
+  PROACTIVE_ACTIVE_HOURS_END = Math.max(
+    0,
+    Math.min(23, config.proactive.activeHours.endHour),
+  );
+  PROACTIVE_QUEUE_OUTSIDE_HOURS =
+    config.proactive.activeHours.queueOutsideHours;
 
   PROACTIVE_DELEGATION_ENABLED = config.proactive.delegation.enabled;
-  PROACTIVE_DELEGATION_MAX_CONCURRENT = Math.max(1, config.proactive.delegation.maxConcurrent);
-  PROACTIVE_DELEGATION_MAX_DEPTH = Math.max(1, config.proactive.delegation.maxDepth);
-  PROACTIVE_DELEGATION_MAX_PER_TURN = Math.max(1, config.proactive.delegation.maxPerTurn);
+  PROACTIVE_DELEGATION_MAX_CONCURRENT = Math.max(
+    1,
+    config.proactive.delegation.maxConcurrent,
+  );
+  PROACTIVE_DELEGATION_MAX_DEPTH = Math.max(
+    1,
+    config.proactive.delegation.maxDepth,
+  );
+  PROACTIVE_DELEGATION_MAX_PER_TURN = Math.max(
+    1,
+    config.proactive.delegation.maxPerTurn,
+  );
 
   PROACTIVE_AUTO_RETRY_ENABLED = config.proactive.autoRetry.enabled;
-  PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS = Math.max(1, config.proactive.autoRetry.maxAttempts);
-  PROACTIVE_AUTO_RETRY_BASE_DELAY_MS = Math.max(100, config.proactive.autoRetry.baseDelayMs);
+  PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS = Math.max(
+    1,
+    config.proactive.autoRetry.maxAttempts,
+  );
+  PROACTIVE_AUTO_RETRY_BASE_DELAY_MS = Math.max(
+    100,
+    config.proactive.autoRetry.baseDelayMs,
+  );
   PROACTIVE_AUTO_RETRY_MAX_DELAY_MS = Math.max(
     PROACTIVE_AUTO_RETRY_BASE_DELAY_MS,
     config.proactive.autoRetry.maxDelayMs,
   );
 
   const rawRalphMax = Math.trunc(config.proactive.ralph.maxIterations);
-  PROACTIVE_RALPH_MAX_ITERATIONS = rawRalphMax === -1 ? -1 : Math.max(0, rawRalphMax);
+  PROACTIVE_RALPH_MAX_ITERATIONS =
+    rawRalphMax === -1 ? -1 : Math.max(0, rawRalphMax);
 }
 
 applyRuntimeConfig(getRuntimeConfig());

package/src/container-runner.ts

@@ -2,7 +2,7 @@
  * Container Runner — manages a pool of persistent containers.
  * Containers stay alive between requests and exit after an idle timeout.
  */
-import { ChildProcess, spawn } from 'child_process';
+import { type ChildProcess, spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
 
@@ -15,7 +15,9 @@ import {
   DATA_DIR,
   GATEWAY_API_TOKEN,
   GATEWAY_BASE_URL,
+  getHybridAIApiKey,
   HYBRIDAI_BASE_URL,
+  HYBRIDAI_MAX_TOKENS,
   HYBRIDAI_MODEL,
   MAX_CONCURRENT_CONTAINERS,
   PROACTIVE_AUTO_RETRY_BASE_DELAY_MS,
@@ -23,9 +25,15 @@ import {
   PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS,
   PROACTIVE_AUTO_RETRY_MAX_DELAY_MS,
   PROACTIVE_RALPH_MAX_ITERATIONS,
-  getHybridAIApiKey,
 } from './config.js';
-import { cleanupIpc, ensureAgentDirs, ensureSessionDirs, getSessionPaths, readOutput, writeInput } from './ipc.js';
+import {
+  cleanupIpc,
+  ensureAgentDirs,
+  ensureSessionDirs,
+  getSessionPaths,
+  readOutput,
+  writeInput,
+} from './ipc.js';
 import { logger } from './logger.js';
 import { validateAdditionalMounts } from './mount-security.js';
 import type {
@@ -52,7 +60,8 @@ interface PoolEntry {
 }
 
 const pool = new Map<string, PoolEntry>();
-const TOOL_RESULT_RE = /^\[tool\]\s+([a-zA-Z0-9_.-]+)\s+result\s+\((\d+)ms\):\s*(.*)$/;
+const TOOL_RESULT_RE =
+  /^\[tool\]\s+([a-zA-Z0-9_.-]+)\s+result\s+\((\d+)ms\):\s*(.*)$/;
 const TOOL_START_RE = /^\[tool\]\s+([a-zA-Z0-9_.-]+):\s*(.*)$/;
 const STREAM_DELTA_RE = /^\[stream\]\s+([A-Za-z0-9+/=]+)$/;
 const CONTAINER_WORKSPACE_ROOT = '/workspace';
@@ -73,7 +82,10 @@ function emitTextDelta(entry: PoolEntry, line: string): void {
     if (!delta) return;
     callback(delta);
   } catch (err) {
-    logger.debug({ sessionId: entry.sessionId, err }, 'Text delta callback failed');
+    logger.debug(
+      { sessionId: entry.sessionId, err },
+      'Text delta callback failed',
+    );
   }
 }
 
@@ -92,7 +104,10 @@ function emitToolProgress(entry: PoolEntry, line: string): void {
         preview: resultMatch[3],
       });
     } catch (err) {
-      logger.debug({ sessionId: entry.sessionId, err }, 'Tool progress callback failed');
+      logger.debug(
+        { sessionId: entry.sessionId, err },
+        'Tool progress callback failed',
+      );
     }
     return;
   }
@@ -107,7 +122,10 @@ function emitToolProgress(entry: PoolEntry, line: string): void {
         preview: startMatch[2],
       });
     } catch (err) {
-      logger.debug({ sessionId: entry.sessionId, err }, 'Tool progress callback failed');
+      logger.debug(
+        { sessionId: entry.sessionId, err },
+        'Tool progress callback failed',
+      );
     }
   }
 }
@@ -119,7 +137,10 @@ export function getActiveContainerCount(): number {
 export function stopSessionContainer(sessionId: string): boolean {
   const entry = pool.get(sessionId);
   if (!entry) return false;
-  logger.info({ sessionId, containerName: entry.containerName }, 'Stopping session container');
+  logger.info(
+    { sessionId, containerName: entry.containerName },
+    'Stopping session container',
+  );
   stopContainer(entry.containerName);
   pool.delete(sessionId);
   return true;
@@ -132,7 +153,10 @@ function stopContainer(containerName: string): void {
   });
 }
 
-function resolveArtifactHostPath(rawPath: string, workspacePath: string): string | null {
+function resolveArtifactHostPath(
+  rawPath: string,
+  workspacePath: string,
+): string | null {
   const input = String(rawPath || '').trim();
   if (!input) return null;
   const normalized = input.replace(/\\/g, '/');
@@ -140,12 +164,20 @@ function resolveArtifactHostPath(rawPath: string, workspacePath: string): string
 
   if (path.posix.isAbsolute(normalized)) {
     const cleanAbs = path.posix.normalize(normalized);
-    if (cleanAbs !== CONTAINER_WORKSPACE_ROOT && !cleanAbs.startsWith(`${CONTAINER_WORKSPACE_ROOT}/`)) {
+    if (
+      cleanAbs !== CONTAINER_WORKSPACE_ROOT &&
+      !cleanAbs.startsWith(`${CONTAINER_WORKSPACE_ROOT}/`)
+    ) {
       return null;
     }
-    const rel = cleanAbs.slice(CONTAINER_WORKSPACE_ROOT.length).replace(/^\/+/, '');
+    const rel = cleanAbs
+      .slice(CONTAINER_WORKSPACE_ROOT.length)
+      .replace(/^\/+/, '');
     const resolved = path.resolve(workspaceRoot, rel);
-    if (resolved === workspaceRoot || resolved.startsWith(`${workspaceRoot}${path.sep}`)) {
+    if (
+      resolved === workspaceRoot ||
+      resolved.startsWith(`${workspaceRoot}${path.sep}`)
+    ) {
       return resolved;
     }
     return null;
@@ -154,21 +186,32 @@ function resolveArtifactHostPath(rawPath: string, workspacePath: string): string
   const cleanRel = path.posix.normalize(normalized);
   if (cleanRel === '..' || cleanRel.startsWith('../')) return null;
   const resolved = path.resolve(workspaceRoot, cleanRel);
-  if (resolved === workspaceRoot || resolved.startsWith(`${workspaceRoot}${path.sep}`)) {
+  if (
+    resolved === workspaceRoot ||
+    resolved.startsWith(`${workspaceRoot}${path.sep}`)
+  ) {
     return resolved;
   }
   return null;
 }
 
-function remapOutputArtifacts(output: ContainerOutput, workspacePath: string): void {
+function remapOutputArtifacts(
+  output: ContainerOutput,
+  workspacePath: string,
+): void {
   if (!Array.isArray(output.artifacts) || output.artifacts.length === 0) return;
   const mapped: ArtifactMetadata[] = [];
   for (const artifact of output.artifacts) {
     const raw = artifact as Partial<ArtifactMetadata>;
-    const hostPath = resolveArtifactHostPath(String(raw.path || ''), workspacePath);
+    const hostPath = resolveArtifactHostPath(
+      String(raw.path || ''),
+      workspacePath,
+    );
     if (!hostPath) continue;
-    const filename = String(raw.filename || '').trim() || path.basename(hostPath);
-    const mimeType = String(raw.mimeType || '').trim() || 'application/octet-stream';
+    const filename =
+      String(raw.filename || '').trim() || path.basename(hostPath);
+    const mimeType =
+      String(raw.mimeType || '').trim() || 'application/octet-stream';
     mapped.push({ path: hostPath, filename, mimeType });
   }
   if (mapped.length === 0) {
@@ -179,7 +222,10 @@ function remapOutputArtifacts(output: ContainerOutput, workspacePath: string): v
 }
 
 function remapHostBaseUrlForContainer(baseUrl: string): string {
-  return baseUrl.replace(/\/\/(localhost|127\.0\.0\.1)([:\/])/, '//host.docker.internal$2');
+  return baseUrl.replace(
+    /\/\/(localhost|127\.0\.0\.1)([:/])/,
+    '//host.docker.internal$2',
+  );
 }
 
 /**
@@ -187,8 +233,15 @@ function remapHostBaseUrlForContainer(baseUrl: string): string {
  */
 function getOrSpawnContainer(sessionId: string, agentId: string): PoolEntry {
   const existing = pool.get(sessionId);
-  if (existing && !existing.process.killed && existing.process.exitCode === null) {
-    logger.debug({ sessionId, containerName: existing.containerName }, 'Reusing container');
+  if (
+    existing &&
+    !existing.process.killed &&
+    existing.process.exitCode === null
+  ) {
+    logger.debug(
+      { sessionId, containerName: existing.containerName },
+      'Reusing container',
+    );
     return existing;
   }
 
@@ -208,23 +261,38 @@ function getOrSpawnContainer(sessionId: string, agentId: string): PoolEntry {
     'run',
     '--rm',
     '-i',
-    '--name', containerName,
-    '--memory', CONTAINER_MEMORY,
+    '--name',
+    containerName,
+    '--memory',
+    CONTAINER_MEMORY,
     `--cpus=${CONTAINER_CPUS}`,
     '--read-only',
-    '--tmpfs', '/tmp',
-    '-v', `${workspacePath}:/workspace:rw`,
-    '-v', `${ipcPath}:/ipc:rw`,
-    '-v', `${mediaCacheHostPath}:${CONTAINER_DISCORD_MEDIA_CACHE_ROOT}:ro`,
-    '-e', `HYBRIDAI_BASE_URL=${HYBRIDAI_BASE_URL}`,
-    '-e', `HYBRIDAI_MODEL=${HYBRIDAI_MODEL}`,
-    '-e', `CONTAINER_IDLE_TIMEOUT=${IDLE_TIMEOUT_MS}`,
-    '-e', `HYBRIDCLAW_RETRY_ENABLED=${PROACTIVE_AUTO_RETRY_ENABLED ? 'true' : 'false'}`,
-    '-e', `HYBRIDCLAW_RETRY_MAX_ATTEMPTS=${PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS}`,
-    '-e', `HYBRIDCLAW_RETRY_BASE_DELAY_MS=${PROACTIVE_AUTO_RETRY_BASE_DELAY_MS}`,
-    '-e', `HYBRIDCLAW_RETRY_MAX_DELAY_MS=${PROACTIVE_AUTO_RETRY_MAX_DELAY_MS}`,
-    '-e', `HYBRIDCLAW_RALPH_MAX_ITERATIONS=${PROACTIVE_RALPH_MAX_ITERATIONS}`,
-    '-e', 'PLAYWRIGHT_BROWSERS_PATH=/ms-playwright',
+    '--tmpfs',
+    '/tmp',
+    '-v',
+    `${workspacePath}:/workspace:rw`,
+    '-v',
+    `${ipcPath}:/ipc:rw`,
+    '-v',
+    `${mediaCacheHostPath}:${CONTAINER_DISCORD_MEDIA_CACHE_ROOT}:ro`,
+    '-e',
+    `HYBRIDAI_BASE_URL=${HYBRIDAI_BASE_URL}`,
+    '-e',
+    `HYBRIDAI_MODEL=${HYBRIDAI_MODEL}`,
+    '-e',
+    `CONTAINER_IDLE_TIMEOUT=${IDLE_TIMEOUT_MS}`,
+    '-e',
+    `HYBRIDCLAW_RETRY_ENABLED=${PROACTIVE_AUTO_RETRY_ENABLED ? 'true' : 'false'}`,
+    '-e',
+    `HYBRIDCLAW_RETRY_MAX_ATTEMPTS=${PROACTIVE_AUTO_RETRY_MAX_ATTEMPTS}`,
+    '-e',
+    `HYBRIDCLAW_RETRY_BASE_DELAY_MS=${PROACTIVE_AUTO_RETRY_BASE_DELAY_MS}`,
+    '-e',
+    `HYBRIDCLAW_RETRY_MAX_DELAY_MS=${PROACTIVE_AUTO_RETRY_MAX_DELAY_MS}`,
+    '-e',
+    `HYBRIDCLAW_RALPH_MAX_ITERATIONS=${PROACTIVE_RALPH_MAX_ITERATIONS}`,
+    '-e',
+    'PLAYWRIGHT_BROWSERS_PATH=/ms-playwright',
   ];
 
   // Run as host user so bind-mount file ownership matches
@@ -241,10 +309,16 @@ function getOrSpawnContainer(sessionId: string, agentId: string): PoolEntry {
       const requested = JSON.parse(ADDITIONAL_MOUNTS) as AdditionalMount[];
       const validated = validateAdditionalMounts(requested);
       for (const m of validated) {
-        args.push('-v', `${m.hostPath}:${m.containerPath}:${m.readonly ? 'ro' : 'rw'}`);
+        args.push(
+          '-v',
+          `${m.hostPath}:${m.containerPath}:${m.readonly ? 'ro' : 'rw'}`,
+        );
       }
     } catch (err) {
-      logger.warn({ error: err instanceof Error ? err.message : String(err) }, 'Failed to parse ADDITIONAL_MOUNTS');
+      logger.warn(
+        { error: err instanceof Error ? err.message : String(err) },
+        'Failed to parse ADDITIONAL_MOUNTS',
+      );
     }
   }
 
@@ -334,7 +408,10 @@ export async function runContainer(
   cleanupIpc(sessionId);
   ensureSessionDirs(sessionId);
 
-  const isNewContainer = !pool.has(sessionId) || pool.get(sessionId)!.process.killed || pool.get(sessionId)!.process.exitCode !== null;
+  const isNewContainer =
+    !pool.has(sessionId) ||
+    pool.get(sessionId)!.process.killed ||
+    pool.get(sessionId)!.process.exitCode !== null;
 
   let entry: PoolEntry;
   try {
@@ -358,6 +435,7 @@ export async function runContainer(
     gatewayBaseUrl: remapHostBaseUrlForContainer(GATEWAY_BASE_URL),
     gatewayApiToken: GATEWAY_API_TOKEN || undefined,
     model,
+    maxTokens: HYBRIDAI_MAX_TOKENS,
     channelId,
     scheduledTasks: scheduledTasks?.map((t) => ({
       id: t.id,
@@ -377,7 +455,10 @@ export async function runContainer(
   entry.onTextDelta = onTextDelta;
   entry.onToolProgress = onToolProgress;
   const onAbort = () => {
-    logger.info({ sessionId, containerName: entry.containerName }, 'Interrupt requested, stopping container');
+    logger.info(
+      { sessionId, containerName: entry.containerName },
+      'Interrupt requested, stopping container',
+    );
     stopContainer(entry.containerName);
   };
   if (abortSignal) {
@@ -397,12 +478,20 @@ export async function runContainer(
     }
 
     // Wait for the container to produce output
-    const output = await readOutput(sessionId, CONTAINER_TIMEOUT, { signal: abortSignal });
+    const output = await readOutput(sessionId, CONTAINER_TIMEOUT, {
+      signal: abortSignal,
+    });
     remapOutputArtifacts(output, workspacePath);
     const duration = Date.now() - startTime;
 
     logger.info(
-      { sessionId, containerName: entry.containerName, duration, status: output.status, toolsUsed: output.toolsUsed },
+      {
+        sessionId,
+        containerName: entry.containerName,
+        duration,
+        status: output.status,
+        toolsUsed: output.toolsUsed,
+      },
       'Request completed',
     );
 
@@ -423,7 +512,10 @@ export async function runContainer(
  */
 export function stopAllContainers(): void {
   for (const [sessionId, entry] of pool) {
-    logger.info({ sessionId, containerName: entry.containerName }, 'Stopping container (shutdown)');
+    logger.info(
+      { sessionId, containerName: entry.containerName },
+      'Stopping container (shutdown)',
+    );
     stopContainer(entry.containerName);
   }
   pool.clear();