@animalabs/connectome-host 0.3.5 → 0.3.8

package/src/modules/channel-mode-module.ts

@@ -7,22 +7,22 @@
  * have to remember (and keep in sync) all three:
  *
  *   debounced  (wake on every message, batched):
- *     1. subscribe to the channel's ambient traffic (`<toolPrefix>--subscribe_channel`)
+ *     1. open the channel (`channel_open`)
  *     2. upsert a per-channel gate policy that DEBOUNCES the ambient tag
  *        (framework.addGatePolicy → gate.json, hot-reloaded) so a burst wakes the
  *        agent once after it settles
  *     3. pin subscription-gc to "off" for the channel, else a chatty channel
- *        auto-unsubscribes itself at the idle-char limit and silently leaves
+ *        auto-closes itself at the idle-char limit and silently leaves
  *        debounced mode
  *
  *   mentions  (revert to mentions/DMs only):
  *     1. remove the per-channel debounce gate policy
- *     2. unsubscribe from ambient traffic
+ *     2. close the channel
  *     3. restore subscription-gc to its default limit
  *
  * The SAME `channelId` string is used for all three subsystems — it's the id the
  * gate sees on an incoming event (`GateEventInfo.channelId`) and the id
- * subscription-gc counts/unsubscribes, so they line up by construction (this is
+ * subscription-gc counts/closes, so they line up by construction (this is
  * exactly how SubscriptionGcModule already operates).
  *
  * Steps are best-effort with per-step reporting rather than a hard transaction:
@@ -45,7 +45,7 @@ import type { AgentFramework } from '@animalabs/agent-framework';
 export interface ChannelModeConfig {
   /** MCPL server id that owns subscriptions (default 'discord'). */
   serverId?: string;
-  /** Tool-name prefix for that server (default `mcpl--<serverId>`). */
+  /** @deprecated Lifecycle tools are host-generic; retained for config compatibility. */
   toolPrefix?: string;
   /** subscription-gc module name, for pinning the idle limit (default 'subscription-gc'). */
   gcModuleName?: string;
@@ -69,13 +69,11 @@ export class ChannelModeModule implements Module {
   private callSeq = 0;
 
   private readonly serverId: string;
-  private readonly toolPrefix: string;
   private readonly gcModuleName: string;
   private readonly defaultDebounceMs: number;
 
   constructor(config: ChannelModeConfig = {}) {
     this.serverId = config.serverId ?? 'discord';
-    this.toolPrefix = config.toolPrefix ?? `mcpl--${this.serverId}`;
     this.gcModuleName = config.gcModuleName ?? 'subscription-gc';
     this.defaultDebounceMs =
       typeof config.defaultDebounceMs === 'number' && config.defaultDebounceMs > 0
@@ -103,12 +101,12 @@ export class ChannelModeModule implements Module {
         name: 'set_channel_mode',
         description:
           'Set how a channel gets your attention, in one step. ' +
-          '`mode: "debounced"` = wake on EVERY message but batched: it subscribes ' +
+          '`mode: "debounced"` = wake on EVERY message but batched: it opens ' +
           'to the channel, adds a gate rule that debounces its ambient traffic ' +
           '(one wake after the burst settles), and pins the channel so it is never ' +
-          'auto-unsubscribed for being chatty. `mode: "mentions"` reverts to ' +
-          'mentions/DMs only: it removes that gate rule, unsubscribes, and restores ' +
-          'the default auto-unsubscribe limit. `debounceMs` (100–300000, default ' +
+          'auto-closed for being chatty. `mode: "mentions"` reverts to ' +
+          'direct-address-only: it removes that gate rule, closes, and restores ' +
+          'the default auto-close limit. `debounceMs` (100–300000, default ' +
           `${this.defaultDebounceMs}) sets the quiet window for debounced mode.`,
         inputSchema: {
           type: 'object',
@@ -182,7 +180,7 @@ export class ChannelModeModule implements Module {
     const steps: StepResult[] = [];
 
     // 1. Subscribe to ambient traffic.
-    steps.push(await this.callToolStep('subscribe', `${this.toolPrefix}--subscribe_channel`, { channelId }));
+    steps.push(await this.callToolStep('open', 'channel_open', { channelId, serverId: this.serverId }));
 
     // 2. Upsert the per-channel ambient debounce policy (prepend so it beats a
     //    broad ambient defer/debounce — first match wins). Validation lives in
@@ -201,7 +199,7 @@ export class ChannelModeModule implements Module {
       steps.push({ step: 'gate-policy', ok: false, detail: errMsg(err) });
     }
 
-    // 3. Pin subscription-gc off so a chatty channel doesn't auto-unsubscribe
+    // 3. Pin subscription-gc off so a chatty channel doesn't auto-close
     //    itself back out of debounced mode.
     steps.push(
       await this.callToolStep('gc-off', `${this.gcModuleName}--set_channel_idle_limit`, {
@@ -224,10 +222,10 @@ export class ChannelModeModule implements Module {
       steps.push({ step: 'gate-policy', ok: false, detail: errMsg(err) });
     }
 
-    // 2. Unsubscribe from ambient traffic.
-    steps.push(await this.callToolStep('unsubscribe', `${this.toolPrefix}--unsubscribe_channel`, { channelId }));
+    // 2. Close ambient traffic through the generic host lifecycle.
+    steps.push(await this.callToolStep('close', 'channel_close', { channelId, serverId: this.serverId }));
 
-    // 3. Restore the default auto-unsubscribe limit.
+    // 3. Restore the default auto-close limit.
     steps.push(
       await this.callToolStep('gc-default', `${this.gcModuleName}--set_channel_idle_limit`, {
         channelId,

package/src/modules/fleet-module.ts

@@ -29,6 +29,7 @@ import type {
   ToolCall,
   ToolResult,
 } from '@animalabs/agent-framework';
+import { formatZonedDateTime, resolveTimeZone } from '@animalabs/agent-framework';
 import { spawn as spawnProcess, type ChildProcess } from 'node:child_process';
 import { connect as netConnect, type Socket } from 'node:net';
 import { existsSync, mkdirSync, unlinkSync, openSync, closeSync, appendFileSync, realpathSync } from 'node:fs';
@@ -81,6 +82,8 @@ interface FleetEventSubscription {
 // ---------------------------------------------------------------------------
 
 export interface FleetModuleConfig {
+  /** IANA zone for wall-clock timestamps returned by fleet tools. */
+  timeZone?: string;
   /** Default subscription sent to children at handshake (default: ['*']). */
   defaultSubscription?: string[];
   /** Max events to retain per child for peek (default: 500). */
@@ -255,6 +258,7 @@ export class FleetModule implements Module {
       sigtermEscalationMs: config.sigtermEscalationMs ?? 5_000,
       childIndexPath: config.childIndexPath ?? process.argv[1] ?? '',
       childRuntimePath: config.childRuntimePath ?? process.execPath,
+      timeZone: resolveTimeZone(config.timeZone),
     };
 
     this.autoStartChildren = config.autoStart ?? [];
@@ -1014,7 +1018,12 @@ export class FleetModule implements Module {
       {
         detached: true,
         stdio: startupFd !== null ? ['ignore', startupFd, startupFd] : 'ignore',
-        env: { ...process.env, ...input.env, DATA_DIR: dataDir },
+        env: {
+          ...process.env,
+          ...input.env,
+          AGENT_TIMEZONE: this.config.timeZone,
+          DATA_DIR: dataDir,
+        },
       },
     );
     proc.unref();
@@ -1095,9 +1104,9 @@ export class FleetModule implements Module {
       name: c.name,
       status: c.status,
       pid: c.pid,
-      startedAt: c.startedAt,
-      exitedAt: c.exitedAt,
-      lastEventAt: c.lastEventAt,
+      startedAt: formatZonedDateTime(c.startedAt, this.config.timeZone),
+      exitedAt: c.exitedAt === null ? null : formatZonedDateTime(c.exitedAt, this.config.timeZone),
+      lastEventAt: c.lastEventAt === null ? null : formatZonedDateTime(c.lastEventAt, this.config.timeZone),
       eventCount: c.events.length,
     }));
     return { success: true, data: list };
@@ -1120,9 +1129,10 @@ export class FleetModule implements Module {
       socketPath: c.socketPath,
       pid: c.pid,
       status: c.status,
-      startedAt: c.startedAt,
-      exitedAt: c.exitedAt,
-      lastEventAt: c.lastEventAt,
+      startedAt: formatZonedDateTime(c.startedAt, this.config.timeZone),
+      exitedAt: c.exitedAt === null ? null : formatZonedDateTime(c.exitedAt, this.config.timeZone),
+      lastEventAt: c.lastEventAt === null ? null : formatZonedDateTime(c.lastEventAt, this.config.timeZone),
+      timeZone: this.config.timeZone,
       exitCode: c.exitCode,
       exitReason: c.exitReason,
       eventCount: c.events.length,

package/src/modules/mcpl-admin-module.ts

@@ -33,6 +33,7 @@ import type {
   AgentFramework,
   McplServerConfig,
 } from '@animalabs/agent-framework';
+import { resolveTimeZone } from '@animalabs/agent-framework';
 import {
   DEFAULT_CONFIG_PATH,
   DEFAULT_AGENT_OVERLAY_PATH,
@@ -44,6 +45,8 @@ import {
 } from '../mcpl-config.js';
 
 export interface McplAdminModuleConfig {
+  /** IANA zone propagated to newly deployed stdio servers. */
+  timeZone?: string;
   /** Path to the agent overlay file. Default: `mcpl-servers.agent.json` in cwd. */
   overlayPath?: string;
   /** Path to the human-owned server config file (read-only here). */
@@ -64,10 +67,12 @@ export class McplAdminModule implements Module {
   private framework: AgentFramework | null = null;
   private overlayPath: string;
   private configPath: string;
+  private timeZone: string;
 
   constructor(config?: McplAdminModuleConfig) {
     this.overlayPath = config?.overlayPath ?? DEFAULT_AGENT_OVERLAY_PATH;
     this.configPath = config?.configPath ?? DEFAULT_CONFIG_PATH;
+    this.timeZone = resolveTimeZone(config?.timeZone);
   }
 
   /** Post-creation wiring (called from index.ts, mirrors ActivityModule.setFramework). */
@@ -109,16 +114,6 @@ export class McplAdminModule implements Module {
             token: { type: 'string', description: 'Bearer token for WebSocket auth.' },
             toolPrefix: { type: 'string', description: 'Tool namespace prefix. Default: mcpl--<id>.' },
             reconnect: { type: 'boolean', description: 'Auto-reconnect on transport failure (default false). Note: does NOT respawn a crashed child — use mcpl_restart for that.' },
-            channelSubscription: {
-              type: 'string',
-              enum: ['auto', 'manual'],
-              description: "Channel auto-open policy: 'auto' (default) opens every channel the server registers; 'manual' opens none. For an allow-list, use channelAllowlist instead.",
-            },
-            channelAllowlist: {
-              type: 'array',
-              items: { type: 'string' },
-              description: 'Allow-list of channel ids to auto-open (overrides channelSubscription).',
-            },
             enabledFeatureSets: { type: 'array', items: { type: 'string' } },
             disabledFeatureSets: { type: 'array', items: { type: 'string' } },
             enabledTools: { type: 'array', items: { type: 'string' }, description: 'Tool allow-list (bare names, * wildcard).' },
@@ -258,11 +253,6 @@ export class McplAdminModule implements Module {
     if (typeof input.token === 'string') entry.token = input.token;
     if (typeof input.toolPrefix === 'string') entry.toolPrefix = input.toolPrefix;
     if (typeof input.reconnect === 'boolean') entry.reconnect = input.reconnect;
-    if (Array.isArray(input.channelAllowlist)) {
-      entry.channelSubscription = input.channelAllowlist.map(String);
-    } else if (input.channelSubscription === 'auto' || input.channelSubscription === 'manual') {
-      entry.channelSubscription = input.channelSubscription;
-    }
     if (Array.isArray(input.enabledFeatureSets)) entry.enabledFeatureSets = input.enabledFeatureSets.map(String);
     if (Array.isArray(input.disabledFeatureSets)) entry.disabledFeatureSets = input.disabledFeatureSets.map(String);
     if (Array.isArray(input.enabledTools)) entry.enabledTools = input.enabledTools.map(String);
@@ -275,6 +265,7 @@ export class McplAdminModule implements Module {
     saveAgentOverlay(this.overlayPath, overlay);
 
     const config = resolveOverlayEntry(id, entry, this.overlayPath) as unknown as McplServerConfig;
+    config.env = { ...(config.env ?? {}), AGENT_TIMEZONE: this.timeZone };
 
     const alreadyLoaded = framework.listMcplServers().some(s => s.id === id);
     try {

package/src/modules/settings-module.ts

@@ -3,10 +3,11 @@
  * itself. State persists to chronicle via ModuleContext (`setState`/`getState`)
  * so changes survive restarts.
  *
- * First domain: **reasoning** (Anthropic extended thinking). Tools:
- *   - reasoning_status                    → show current state
- *   - reasoning_enable {budgetTokens?}    → turn on with optional budget
- *   - reasoning_disable                   → turn off
+ * First domain: **reasoning** (Anthropic extended thinking), surfaced to the
+ * agent as `agent_settings` fields (reasoning_enabled /
+ * reasoning_budget_tokens) via the framework's settings-extension hook —
+ * NOT as standalone tools (the former reasoning_status/enable/disable trio
+ * was tool bloat for one boolean + number).
  *
  * The host's adapter wrapper (LoggingAnthropicAdapter) reads `getReasoning()`
  * on each call and injects `thinking: {type:'enabled', budget_tokens: N}` into
@@ -69,75 +70,98 @@ export class SettingsModule implements Module {
     return { ...this.state.reasoning };
   }
 
+  /** No standalone tools — reasoning controls live inside the framework's
+   *  `agent_settings` tool via getAgentSettingsExtension() below. The three
+   *  former reasoning_* tools were pure tool bloat for one boolean + number. */
   getTools(): ToolDefinition[] {
-    return [
-      {
-        name: 'reasoning_status',
-        description:
-          'Show whether extended thinking (reasoning) is currently enabled and the token budget.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      {
-        name: 'reasoning_enable',
-        description:
-          'Enable extended thinking (reasoning) on your subsequent inference calls. ' +
-          'Optional budgetTokens in tokens (default: current value, initially 8192; min 1024).',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            budgetTokens: {
-              type: 'number',
-              description: 'Token budget for thinking blocks (min 1024).',
-            },
-          },
-        },
-      },
-      {
-        name: 'reasoning_disable',
-        description:
-          'Disable extended thinking (reasoning). Subsequent inference calls will not request thinking blocks.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-    ];
+    return [];
   }
 
   async handleToolCall(call: ToolCall): Promise<ToolResult> {
-    const input = (call.input ?? {}) as Record<string, unknown>;
-    switch (call.name) {
-      case 'reasoning_status':
-        return ok(this.reasoningStatusText());
-      case 'reasoning_enable': {
-        const budget =
-          typeof input.budgetTokens === 'number'
-            ? Math.max(1024, Math.round(input.budgetTokens))
-            : this.state.reasoning.budgetTokens;
-        this.state.reasoning = { enabled: true, budgetTokens: budget };
+    return {
+      success: false,
+      error:
+        `Unknown tool: ${call.name}. Reasoning controls moved into agent_settings ` +
+        `(fields reasoning_enabled / reasoning_budget_tokens).`,
+      isError: true,
+    };
+  }
+
+  /**
+   * Declare reasoning as an agent_settings extension: the framework merges
+   * these fields into the agent_settings tool and routes get/update/reset for
+   * them back here. Framework versions predating the hook simply never call
+   * this — in that case reasoning is temporarily not agent-tunable (the
+   * adapter still honors persisted state).
+   */
+  getAgentSettingsExtension(): {
+    properties: Record<string, unknown>;
+    keys: string[];
+    get(agentName: string): Record<string, unknown>;
+    update(agentName: string, patch: Record<string, unknown>): Record<string, unknown>;
+    reset(agentName: string, keys?: string[]): Record<string, unknown>;
+  } {
+    return {
+      properties: {
+        reasoning_enabled: {
+          type: 'boolean',
+          description:
+            'Extended thinking (reasoning) on subsequent inference calls.',
+        },
+        reasoning_budget_tokens: {
+          type: 'number',
+          description: 'Token budget for thinking blocks (min 1024).',
+        },
+      },
+      keys: ['reasoning_enabled', 'reasoning_budget_tokens'],
+      get: () => this.reasoningSettingsView(),
+      update: (_agentName, patch) => {
+        const next = { ...this.state.reasoning };
+        if (patch.reasoning_enabled !== undefined) {
+          if (typeof patch.reasoning_enabled !== 'boolean') {
+            throw new Error('reasoning_enabled must be a boolean');
+          }
+          next.enabled = patch.reasoning_enabled;
+        }
+        if (patch.reasoning_budget_tokens !== undefined) {
+          const budget = Number(patch.reasoning_budget_tokens);
+          if (!Number.isFinite(budget)) {
+            throw new Error('reasoning_budget_tokens must be a number');
+          }
+          next.budgetTokens = Math.max(1024, Math.round(budget));
+        }
+        this.state.reasoning = next;
         this.ctx?.setState(this.state);
-        return ok('Reasoning enabled. ' + this.reasoningStatusText());
-      }
-      case 'reasoning_disable':
-        this.state.reasoning = { ...this.state.reasoning, enabled: false };
+        return this.reasoningSettingsView();
+      },
+      reset: (_agentName, keys) => {
+        const all = !keys || keys.length === 0;
+        if (all || keys?.includes('reasoning_enabled')) {
+          this.state.reasoning.enabled = DEFAULTS.reasoning.enabled;
+        }
+        if (all || keys?.includes('reasoning_budget_tokens')) {
+          this.state.reasoning.budgetTokens = DEFAULTS.reasoning.budgetTokens;
+        }
         this.ctx?.setState(this.state);
-        return ok('Reasoning disabled. ' + this.reasoningStatusText());
-      default:
-        return { success: false, error: `Unknown tool: ${call.name}`, isError: true };
-    }
+        return this.reasoningSettingsView();
+      },
+    };
+  }
+
+  /** The extension's wire view of reasoning state (flat agent_settings keys). */
+  private reasoningSettingsView(): Record<string, unknown> {
+    return {
+      reasoning_enabled: this.state.reasoning.enabled,
+      reasoning_budget_tokens: this.state.reasoning.budgetTokens,
+    };
   }
 
   async onProcess(_event: ProcessEvent, _state: ProcessState): Promise<EventResponse> {
     return {};
   }
 
-  private reasoningStatusText(): string {
-    const r = this.state.reasoning;
-    return `reasoning=${r.enabled ? 'ENABLED' : 'disabled'}, budgetTokens=${r.budgetTokens}`;
-  }
 }
 
 function clone<T>(x: T): T {
   return JSON.parse(JSON.stringify(x)) as T;
 }
-
-function ok(message: string): ToolResult {
-  return { success: true, data: { message }, isError: false };
-}

package/src/modules/subscription-gc-module.ts

@@ -1,5 +1,5 @@
 /**
- * SubscriptionGcModule — auto-unsubscribe noisy ambient Discord channels.
+ * SubscriptionGcModule — auto-close noisy ordinary channel traffic.
  *
  * Problem: a subscribed channel delivers ambient (non-mention, non-DM) messages
  * into the agent's context whether or not the agent ever acts on them. A busy
@@ -12,7 +12,7 @@
  *     the agent saw every subscribed channel in that context (compressed if
  *     large; nothing is dropped), so the slate is clean.
  *   - The instant a channel's since-last-activation count crosses its limit, it
- *     is auto-unsubscribed via the surface's `unsubscribe_channel` tool. This
+ *     is auto-closed via the host's generic `channel_close` tool. This
  *     bounds any one channel's context pollution to ~limit characters.
  *
  * Everything is durable across restarts: counters + per-channel overrides
@@ -36,15 +36,15 @@ import type {
 } from '@animalabs/agent-framework';
 
 export interface SubscriptionGcConfig {
-  /** Default ambient-character budget per channel before auto-unsubscribe. */
+  /** Default ambient-character budget per channel before auto-close. */
   defaultLimitChars?: number;
   /** MCPL server id that owns subscriptions (default 'discord'). */
   serverId?: string;
-  /** Tool-name prefix for that server (default `mcpl--<serverId>`). */
+  /** @deprecated Lifecycle tools are host-generic; retained for config compatibility. */
   toolPrefix?: string;
 }
 
-/** `'off'` pins a channel (never auto-unsubscribe); a number overrides the
+/** `'off'` pins a channel (never auto-close); a number overrides the
  *  default limit; absence falls back to the default. */
 type LimitOverride = number | 'off';
 
@@ -66,7 +66,6 @@ export class SubscriptionGcModule implements Module {
 
   private readonly defaultLimitChars: number;
   private readonly serverId: string;
-  private readonly toolPrefix: string;
 
   private state: GcState = { overrides: {}, counters: {} };
 
@@ -76,7 +75,6 @@ export class SubscriptionGcModule implements Module {
         ? Math.round(config.defaultLimitChars)
         : 20000;
     this.serverId = config.serverId ?? 'discord';
-    this.toolPrefix = config.toolPrefix ?? `mcpl--${this.serverId}`;
   }
 
   async start(ctx: ModuleContext): Promise<void> {
@@ -121,9 +119,9 @@ export class SubscriptionGcModule implements Module {
         description:
           'Set how many characters of ambient (non-mention, non-DM) traffic a ' +
           'subscribed channel may emit between your activations before it is ' +
-          'auto-unsubscribed. `limit` is a number of characters, "default" to ' +
+          'auto-closed. `limit` is a number of characters, "default" to ' +
           `use the global default (${this.defaultLimitChars}), or "off" to ` +
-          'never auto-unsubscribe this channel.',
+          'never auto-close this channel.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -139,7 +137,7 @@ export class SubscriptionGcModule implements Module {
       {
         name: 'list_channel_idle_limits',
         description:
-          'Show the auto-unsubscribe configuration: the global default limit, ' +
+          'Show the auto-close configuration: the global default limit, ' +
           'per-channel overrides, and the current since-last-activation ambient ' +
           'character counts per channel.',
         inputSchema: { type: 'object', properties: {} },
@@ -169,7 +167,7 @@ export class SubscriptionGcModule implements Module {
           desc = `default (${this.defaultLimitChars})`;
         } else if (limit === 'off') {
           this.state.overrides[channelId] = 'off';
-          desc = 'off (never auto-unsubscribe)';
+          desc = 'off (never auto-close)';
         } else if (Number.isFinite(numeric) && numeric > 0) {
           this.state.overrides[channelId] = Math.round(numeric);
           desc = `${Math.round(numeric)} characters`;
@@ -207,14 +205,14 @@ export class SubscriptionGcModule implements Module {
     const next = (this.state.counters[channelId] ?? 0) + chars;
 
     if (limit !== Infinity && next > limit) {
-      // Cross the threshold → unsubscribe and clear the counter.
+      // Cross the threshold → close and clear the counter.
       delete this.state.counters[channelId];
       this.persistNow();
       const result = await this.ctx
         ?.callTool({
           id: `gc-unsub-${this.callSeq++}`,
-          name: `${this.toolPrefix}--unsubscribe_channel`,
-          input: { channelId },
+          name: 'channel_close',
+          input: { channelId, serverId: this.serverId },
         })
         .catch((err: unknown) => ({
           success: false,
@@ -231,18 +229,17 @@ export class SubscriptionGcModule implements Module {
                 {
                   type: 'text',
                   text:
-                    `[subscription-gc] Auto-unsubscribed from channel ${channelId}: it emitted ` +
+                    `[subscription-gc] Auto-closed channel ${channelId}: it emitted ` +
                     `over ${limit} characters of ambient traffic since your last activation without ` +
-                    `engagement. Mentions and DMs there still reach you. Resubscribe with ` +
-                    `${this.toolPrefix}--subscribe_channel, raise/disable its limit with ` +
-                    `set_channel_idle_limit, or check what you're missing with ${this.toolPrefix}--channel_missed.`,
+                    `engagement. Direct addresses there still reach you. Reopen with channel_open, ` +
+                    `or raise/disable its limit with set_channel_idle_limit.`,
                 },
               ],
             },
           ],
         };
       }
-      // Unsubscribe failed — keep the channel counted so we retry on the next
+      // Close failed — keep the channel counted so we retry on the next
       // ambient message rather than silently giving up.
       this.state.counters[channelId] = next;
       this.persistNow();
@@ -270,7 +267,7 @@ export class SubscriptionGcModule implements Module {
       if (event.serverId !== this.serverId) return null;
       const origin = (event.origin ?? {}) as Record<string, unknown>;
       if (origin.isMention || origin.isDM) return null;
-      const channelId = origin.channelId;
+      const channelId = origin.mcplChannelId ?? origin.channelId;
       if (typeof channelId !== 'string' || channelId.length === 0) return null;
       return { channelId, chars: textLen(event.content) };
     }

package/src/modules/time-module.ts

@@ -15,21 +15,23 @@ import type {
   ToolCall,
   ToolResult,
 } from '@animalabs/agent-framework';
+import { formatZonedDateTime, resolveTimeZone } from '@animalabs/agent-framework';
 
 interface TimeState {
   sessionStartAnnounced?: boolean;
 }
 
-function formatNow(date: Date = new Date()): {
+export function formatNow(date: Date = new Date(), configuredTimeZone?: string): {
   iso: string;
   local: string;
   timezone: string;
   unixMs: number;
 } {
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const timezone = resolveTimeZone(configuredTimeZone);
+  const local = formatZonedDateTime(date, timezone);
   return {
-    iso: date.toISOString(),
-    local: date.toString(),
+    iso: local.slice(0, local.indexOf(' [')),
+    local,
     timezone,
     unixMs: date.getTime(),
   };
@@ -39,6 +41,11 @@ export class TimeModule implements Module {
   readonly name = 'time';
 
   private ctx: ModuleContext | null = null;
+  private readonly timeZone: string;
+
+  constructor(timeZone?: string) {
+    this.timeZone = resolveTimeZone(timeZone);
+  }
 
   async start(ctx: ModuleContext): Promise<void> {
     this.ctx = ctx;
@@ -46,10 +53,9 @@ export class TimeModule implements Module {
     const state = ctx.getState<TimeState>() ?? {};
     if (state.sessionStartAnnounced) return;
 
-    const now = formatNow();
+    const now = formatNow(new Date(), this.timeZone);
     const text =
-      `The time at the start of this session is: ${now.iso} ` +
-      `(local: ${now.local}, timezone: ${now.timezone}).`;
+      `The local time at the start of this session is ${now.local}.`;
 
     ctx.addMessage('user', [{ type: 'text', text }]);
     ctx.setState<TimeState>({ ...state, sessionStartAnnounced: true });
@@ -67,7 +73,7 @@ export class TimeModule implements Module {
     return [
       {
         name: 'now',
-        description: 'Return the current wall-clock time as ISO 8601, local string, timezone, and unix milliseconds.',
+        description: 'Return the current wall-clock time in the agent-configured timezone, plus unix milliseconds.',
         inputSchema: {
           type: 'object',
           properties: {},
@@ -78,7 +84,7 @@ export class TimeModule implements Module {
 
   async handleToolCall(call: ToolCall): Promise<ToolResult> {
     if (call.name === 'now') {
-      return { success: true, data: formatNow() };
+      return { success: true, data: formatNow(new Date(), this.timeZone) };
     }
     return { success: false, isError: true, error: `Unknown tool: ${call.name}` };
   }