@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/gateway/protocol/schema/agents-models-skills.js

@@ -25,11 +25,81 @@ export const AgentsListResultSchema = Type.Object({
     scope: Type.Union([Type.Literal("per-sender"), Type.Literal("global")]),
     agents: Type.Array(AgentSummarySchema),
 }, { additionalProperties: false });
+export const AgentsCreateParamsSchema = Type.Object({
+    name: NonEmptyString,
+    workspace: NonEmptyString,
+    emoji: Type.Optional(Type.String()),
+    avatar: Type.Optional(Type.String()),
+}, { additionalProperties: false });
+export const AgentsCreateResultSchema = Type.Object({
+    ok: Type.Literal(true),
+    agentId: NonEmptyString,
+    name: NonEmptyString,
+    workspace: NonEmptyString,
+}, { additionalProperties: false });
+export const AgentsUpdateParamsSchema = Type.Object({
+    agentId: NonEmptyString,
+    name: Type.Optional(NonEmptyString),
+    workspace: Type.Optional(NonEmptyString),
+    model: Type.Optional(NonEmptyString),
+    avatar: Type.Optional(Type.String()),
+}, { additionalProperties: false });
+export const AgentsUpdateResultSchema = Type.Object({
+    ok: Type.Literal(true),
+    agentId: NonEmptyString,
+}, { additionalProperties: false });
+export const AgentsDeleteParamsSchema = Type.Object({
+    agentId: NonEmptyString,
+    deleteFiles: Type.Optional(Type.Boolean()),
+}, { additionalProperties: false });
+export const AgentsDeleteResultSchema = Type.Object({
+    ok: Type.Literal(true),
+    agentId: NonEmptyString,
+    removedBindings: Type.Integer({ minimum: 0 }),
+}, { additionalProperties: false });
+export const AgentsFileEntrySchema = Type.Object({
+    name: NonEmptyString,
+    path: NonEmptyString,
+    missing: Type.Boolean(),
+    size: Type.Optional(Type.Integer({ minimum: 0 })),
+    updatedAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
+    content: Type.Optional(Type.String()),
+}, { additionalProperties: false });
+export const AgentsFilesListParamsSchema = Type.Object({
+    agentId: NonEmptyString,
+}, { additionalProperties: false });
+export const AgentsFilesListResultSchema = Type.Object({
+    agentId: NonEmptyString,
+    workspace: NonEmptyString,
+    files: Type.Array(AgentsFileEntrySchema),
+}, { additionalProperties: false });
+export const AgentsFilesGetParamsSchema = Type.Object({
+    agentId: NonEmptyString,
+    name: NonEmptyString,
+}, { additionalProperties: false });
+export const AgentsFilesGetResultSchema = Type.Object({
+    agentId: NonEmptyString,
+    workspace: NonEmptyString,
+    file: AgentsFileEntrySchema,
+}, { additionalProperties: false });
+export const AgentsFilesSetParamsSchema = Type.Object({
+    agentId: NonEmptyString,
+    name: NonEmptyString,
+    content: Type.String(),
+}, { additionalProperties: false });
+export const AgentsFilesSetResultSchema = Type.Object({
+    ok: Type.Literal(true),
+    agentId: NonEmptyString,
+    workspace: NonEmptyString,
+    file: AgentsFileEntrySchema,
+}, { additionalProperties: false });
 export const ModelsListParamsSchema = Type.Object({}, { additionalProperties: false });
 export const ModelsListResultSchema = Type.Object({
     models: Type.Array(ModelChoiceSchema),
 }, { additionalProperties: false });
-export const SkillsStatusParamsSchema = Type.Object({}, { additionalProperties: false });
+export const SkillsStatusParamsSchema = Type.Object({
+    agentId: Type.Optional(NonEmptyString),
+}, { additionalProperties: false });
 export const SkillsBinsParamsSchema = Type.Object({}, { additionalProperties: false });
 export const SkillsBinsResultSchema = Type.Object({
     bins: Type.Array(NonEmptyString),

package/dist/gateway/protocol/schema/cron.js

@@ -3,7 +3,7 @@ import { NonEmptyString } from "./primitives.js";
 export const CronScheduleSchema = Type.Union([
     Type.Object({
         kind: Type.Literal("at"),
-        atMs: Type.Integer({ minimum: 0 }),
+        at: NonEmptyString,
     }, { additionalProperties: false }),
     Type.Object({
         kind: Type.Literal("every"),
@@ -27,8 +27,9 @@ export const CronPayloadSchema = Type.Union([
         model: Type.Optional(Type.String()),
         thinking: Type.Optional(Type.String()),
         timeoutSeconds: Type.Optional(Type.Integer({ minimum: 1 })),
+        allowUnsafeExternalContent: Type.Optional(Type.Boolean()),
         deliver: Type.Optional(Type.Boolean()),
-        channel: Type.Optional(Type.Union([Type.Literal("last"), NonEmptyString])),
+        channel: Type.Optional(Type.String()),
         to: Type.Optional(Type.String()),
         bestEffortDeliver: Type.Optional(Type.Boolean()),
     }, { additionalProperties: false }),
@@ -44,16 +45,24 @@ export const CronPayloadPatchSchema = Type.Union([
         model: Type.Optional(Type.String()),
         thinking: Type.Optional(Type.String()),
         timeoutSeconds: Type.Optional(Type.Integer({ minimum: 1 })),
+        allowUnsafeExternalContent: Type.Optional(Type.Boolean()),
         deliver: Type.Optional(Type.Boolean()),
-        channel: Type.Optional(Type.Union([Type.Literal("last"), NonEmptyString])),
+        channel: Type.Optional(Type.String()),
         to: Type.Optional(Type.String()),
         bestEffortDeliver: Type.Optional(Type.Boolean()),
     }, { additionalProperties: false }),
 ]);
-export const CronIsolationSchema = Type.Object({
-    postToMainPrefix: Type.Optional(Type.String()),
-    postToMainMode: Type.Optional(Type.Union([Type.Literal("summary"), Type.Literal("full")])),
-    postToMainMaxChars: Type.Optional(Type.Integer({ minimum: 0 })),
+export const CronDeliverySchema = Type.Object({
+    mode: Type.Union([Type.Literal("none"), Type.Literal("announce")]),
+    channel: Type.Optional(Type.Union([Type.Literal("last"), NonEmptyString])),
+    to: Type.Optional(Type.String()),
+    bestEffort: Type.Optional(Type.Boolean()),
+}, { additionalProperties: false });
+export const CronDeliveryPatchSchema = Type.Object({
+    mode: Type.Optional(Type.Union([Type.Literal("none"), Type.Literal("announce")])),
+    channel: Type.Optional(Type.Union([Type.Literal("last"), NonEmptyString])),
+    to: Type.Optional(Type.String()),
+    bestEffort: Type.Optional(Type.Boolean()),
 }, { additionalProperties: false });
 export const CronJobStateSchema = Type.Object({
     nextRunAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
@@ -62,6 +71,7 @@ export const CronJobStateSchema = Type.Object({
     lastStatus: Type.Optional(Type.Union([Type.Literal("ok"), Type.Literal("error"), Type.Literal("skipped")])),
     lastError: Type.Optional(Type.String()),
     lastDurationMs: Type.Optional(Type.Integer({ minimum: 0 })),
+    consecutiveErrors: Type.Optional(Type.Integer({ minimum: 0 })),
 }, { additionalProperties: false });
 export const CronJobSchema = Type.Object({
     id: NonEmptyString,
@@ -76,7 +86,7 @@ export const CronJobSchema = Type.Object({
     sessionTarget: Type.Union([Type.Literal("main"), Type.Literal("isolated")]),
     wakeMode: Type.Union([Type.Literal("next-heartbeat"), Type.Literal("now")]),
     payload: CronPayloadSchema,
-    isolation: Type.Optional(CronIsolationSchema),
+    delivery: Type.Optional(CronDeliverySchema),
     state: CronJobStateSchema,
 }, { additionalProperties: false });
 export const CronListParamsSchema = Type.Object({
@@ -93,7 +103,7 @@ export const CronAddParamsSchema = Type.Object({
     sessionTarget: Type.Union([Type.Literal("main"), Type.Literal("isolated")]),
     wakeMode: Type.Union([Type.Literal("next-heartbeat"), Type.Literal("now")]),
     payload: CronPayloadSchema,
-    isolation: Type.Optional(CronIsolationSchema),
+    delivery: Type.Optional(CronDeliverySchema),
 }, { additionalProperties: false });
 export const CronJobPatchSchema = Type.Object({
     name: Type.Optional(NonEmptyString),
@@ -105,7 +115,7 @@ export const CronJobPatchSchema = Type.Object({
     sessionTarget: Type.Optional(Type.Union([Type.Literal("main"), Type.Literal("isolated")])),
     wakeMode: Type.Optional(Type.Union([Type.Literal("next-heartbeat"), Type.Literal("now")])),
     payload: Type.Optional(CronPayloadPatchSchema),
-    isolation: Type.Optional(CronIsolationSchema),
+    delivery: Type.Optional(CronDeliveryPatchSchema),
     state: Type.Optional(Type.Partial(CronJobStateSchema)),
 }, { additionalProperties: false });
 export const CronUpdateParamsSchema = Type.Union([
@@ -153,6 +163,8 @@ export const CronRunLogEntrySchema = Type.Object({
     status: Type.Optional(Type.Union([Type.Literal("ok"), Type.Literal("error"), Type.Literal("skipped")])),
     error: Type.Optional(Type.String()),
     summary: Type.Optional(Type.String()),
+    sessionId: Type.Optional(NonEmptyString),
+    sessionKey: Type.Optional(NonEmptyString),
     runAtMs: Type.Optional(Type.Integer({ minimum: 0 })),
     durationMs: Type.Optional(Type.Integer({ minimum: 0 })),
     nextRunAtMs: Type.Optional(Type.Integer({ minimum: 0 })),

package/dist/gateway/protocol/schema/protocol-schemas.js

@@ -1,5 +1,5 @@
 import { AgentEventSchema, AgentIdentityParamsSchema, AgentIdentityResultSchema, AgentParamsSchema, AgentWaitParamsSchema, PollParamsSchema, SendParamsSchema, WakeParamsSchema, } from "./agent.js";
-import { AgentSummarySchema, AgentsListParamsSchema, AgentsListResultSchema, ModelChoiceSchema, ModelsListParamsSchema, ModelsListResultSchema, SkillsBinsParamsSchema, SkillsBinsResultSchema, SkillsInstallParamsSchema, SkillsStatusParamsSchema, SkillsUpdateParamsSchema, } from "./agents-models-skills.js";
+import { AgentSummarySchema, AgentsCreateParamsSchema, AgentsCreateResultSchema, AgentsDeleteParamsSchema, AgentsDeleteResultSchema, AgentsFileEntrySchema, AgentsFilesGetParamsSchema, AgentsFilesGetResultSchema, AgentsFilesListParamsSchema, AgentsFilesListResultSchema, AgentsFilesSetParamsSchema, AgentsFilesSetResultSchema, AgentsListParamsSchema, AgentsListResultSchema, AgentsUpdateParamsSchema, AgentsUpdateResultSchema, ModelChoiceSchema, ModelsListParamsSchema, ModelsListResultSchema, SkillsBinsParamsSchema, SkillsBinsResultSchema, SkillsInstallParamsSchema, SkillsStatusParamsSchema, SkillsUpdateParamsSchema, } from "./agents-models-skills.js";
 import { ChannelsLogoutParamsSchema, ChannelsStatusParamsSchema, ChannelsStatusResultSchema, TalkModeParamsSchema, WebLoginStartParamsSchema, WebLoginWaitParamsSchema, } from "./channels.js";
 import { ConfigApplyParamsSchema, ConfigGetParamsSchema, ConfigPatchParamsSchema, ConfigSchemaParamsSchema, ConfigSchemaResponseSchema, ConfigSetParamsSchema, UpdateRunParamsSchema, } from "./config.js";
 import { CronAddParamsSchema, CronJobSchema, CronListParamsSchema, CronRemoveParamsSchema, CronRunLogEntrySchema, CronRunParamsSchema, CronRunsParamsSchema, CronStatusParamsSchema, CronUpdateParamsSchema, } from "./cron.js";
@@ -8,7 +8,7 @@ import { DevicePairApproveParamsSchema, DevicePairListParamsSchema, DevicePairRe
 import { ConnectParamsSchema, ErrorShapeSchema, EventFrameSchema, GatewayFrameSchema, HelloOkSchema, RequestFrameSchema, ResponseFrameSchema, ShutdownEventSchema, TickEventSchema, } from "./frames.js";
 import { ChatAbortParamsSchema, ChatEventSchema, ChatHistoryParamsSchema, ChatInjectParamsSchema, ChatSendParamsSchema, LogsTailParamsSchema, LogsTailResultSchema, } from "./logs-chat.js";
 import { NodeDescribeParamsSchema, NodeEventParamsSchema, NodeInvokeParamsSchema, NodeInvokeResultParamsSchema, NodeInvokeRequestEventSchema, NodeListParamsSchema, NodePairApproveParamsSchema, NodePairListParamsSchema, NodePairRejectParamsSchema, NodePairRequestParamsSchema, NodePairVerifyParamsSchema, NodeRenameParamsSchema, } from "./nodes.js";
-import { SessionsCompactParamsSchema, SessionsDeleteParamsSchema, SessionsListParamsSchema, SessionsPatchParamsSchema, SessionsPreviewParamsSchema, SessionsResetParamsSchema, SessionsResolveParamsSchema, } from "./sessions.js";
+import { SessionsCompactParamsSchema, SessionsDeleteParamsSchema, SessionsListParamsSchema, SessionsPatchParamsSchema, SessionsPreviewParamsSchema, SessionsResetParamsSchema, SessionsResolveParamsSchema, SessionsUsageParamsSchema, } from "./sessions.js";
 import { PresenceEntrySchema, SnapshotSchema, StateVersionSchema } from "./snapshot.js";
 import { WizardCancelParamsSchema, WizardNextParamsSchema, WizardNextResultSchema, WizardStartParamsSchema, WizardStartResultSchema, WizardStatusParamsSchema, WizardStatusResultSchema, WizardStepSchema, } from "./wizard.js";
 export const ProtocolSchemas = {
@@ -49,6 +49,7 @@ export const ProtocolSchemas = {
     SessionsResetParams: SessionsResetParamsSchema,
     SessionsDeleteParams: SessionsDeleteParamsSchema,
     SessionsCompactParams: SessionsCompactParamsSchema,
+    SessionsUsageParams: SessionsUsageParamsSchema,
     ConfigGetParams: ConfigGetParamsSchema,
     ConfigSetParams: ConfigSetParamsSchema,
     ConfigApplyParams: ConfigApplyParamsSchema,
@@ -72,6 +73,19 @@ export const ProtocolSchemas = {
     AgentSummary: AgentSummarySchema,
     AgentsListParams: AgentsListParamsSchema,
     AgentsListResult: AgentsListResultSchema,
+    AgentsCreateParams: AgentsCreateParamsSchema,
+    AgentsCreateResult: AgentsCreateResultSchema,
+    AgentsUpdateParams: AgentsUpdateParamsSchema,
+    AgentsUpdateResult: AgentsUpdateResultSchema,
+    AgentsDeleteParams: AgentsDeleteParamsSchema,
+    AgentsDeleteResult: AgentsDeleteResultSchema,
+    AgentsFileEntry: AgentsFileEntrySchema,
+    AgentsFilesListParams: AgentsFilesListParamsSchema,
+    AgentsFilesListResult: AgentsFilesListResultSchema,
+    AgentsFilesGetParams: AgentsFilesGetParamsSchema,
+    AgentsFilesGetResult: AgentsFilesGetResultSchema,
+    AgentsFilesSetParams: AgentsFilesSetParamsSchema,
+    AgentsFilesSetResult: AgentsFilesSetResultSchema,
     ModelChoice: ModelChoiceSchema,
     ModelsListParams: ModelsListParamsSchema,
     ModelsListResult: ModelsListResultSchema,

package/dist/gateway/protocol/schema/sessions.js

@@ -67,3 +67,15 @@ export const SessionsCompactParamsSchema = Type.Object({
     key: NonEmptyString,
     maxLines: Type.Optional(Type.Integer({ minimum: 1 })),
 }, { additionalProperties: false });
+export const SessionsUsageParamsSchema = Type.Object({
+    /** Specific session key to analyze; if omitted returns all sessions. */
+    key: Type.Optional(NonEmptyString),
+    /** Start date for range filter (YYYY-MM-DD). */
+    startDate: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })),
+    /** End date for range filter (YYYY-MM-DD). */
+    endDate: Type.Optional(Type.String({ pattern: "^\\d{4}-\\d{2}-\\d{2}$" })),
+    /** Maximum sessions to return (default 50). */
+    limit: Type.Optional(Type.Integer({ minimum: 1 })),
+    /** Include context weight breakdown (systemPromptReport). */
+    includeContextWeight: Type.Optional(Type.Boolean()),
+}, { additionalProperties: false });

package/dist/gateway/server/hooks.js

@@ -25,7 +25,7 @@ export function createGatewayHooksRequestHandler(params) {
             enabled: true,
             createdAtMs: now,
             updatedAtMs: now,
-            schedule: { kind: "at", atMs: now },
+            schedule: { kind: "at", at: new Date(now).toISOString() },
             sessionTarget: "isolated",
             wakeMode: value.wakeMode,
             payload: {

package/dist/gateway/server-broadcast.js

@@ -13,20 +13,24 @@ const EVENT_SCOPE_GUARDS = {
 };
 function hasEventScope(client, event) {
     const required = EVENT_SCOPE_GUARDS[event];
-    if (!required)
+    if (!required) {
         return true;
+    }
     const role = client.connect.role ?? "operator";
-    if (role !== "operator")
+    if (role !== "operator") {
         return false;
+    }
     const scopes = Array.isArray(client.connect.scopes) ? client.connect.scopes : [];
-    if (scopes.includes(ADMIN_SCOPE))
+    if (scopes.includes(ADMIN_SCOPE)) {
         return true;
+    }
     return required.some((scope) => scopes.includes(scope));
 }
 export function createGatewayBroadcaster(params) {
     let seq = 0;
-    const broadcast = (event, payload, opts) => {
-        const eventSeq = ++seq;
+    const broadcastInternal = (event, payload, opts, targetConnIds) => {
+        const isTargeted = Boolean(targetConnIds);
+        const eventSeq = isTargeted ? undefined : ++seq;
         const frame = JSON.stringify({
             type: "event",
             event,
@@ -36,8 +40,9 @@ export function createGatewayBroadcaster(params) {
         });
         const logMeta = {
             event,
-            seq: eventSeq,
+            seq: eventSeq ?? "targeted",
             clients: params.clients.size,
+            targets: targetConnIds ? targetConnIds.size : undefined,
             dropIfSlow: opts?.dropIfSlow,
             presenceVersion: opts?.stateVersion?.presence,
             healthVersion: opts?.stateVersion?.health,
@@ -47,11 +52,16 @@ export function createGatewayBroadcaster(params) {
         }
         logWs("out", "event", logMeta);
         for (const c of params.clients) {
-            if (!hasEventScope(c, event))
+            if (targetConnIds && !targetConnIds.has(c.connId)) {
+                continue;
+            }
+            if (!hasEventScope(c, event)) {
                 continue;
+            }
             const slow = c.socket.bufferedAmount > MAX_BUFFERED_BYTES;
-            if (slow && opts?.dropIfSlow)
+            if (slow && opts?.dropIfSlow) {
                 continue;
+            }
             if (slow) {
                 try {
                     c.socket.close(1008, "slow consumer");
@@ -69,5 +79,12 @@ export function createGatewayBroadcaster(params) {
             }
         }
     };
-    return { broadcast };
+    const broadcast = (event, payload, opts) => broadcastInternal(event, payload, opts);
+    const broadcastToConnIds = (event, payload, connIds, opts) => {
+        if (connIds.size === 0) {
+            return;
+        }
+        broadcastInternal(event, payload, opts, connIds);
+    };
+    return { broadcast, broadcastToConnIds };
 }

package/dist/gateway/server-chat.js

@@ -10,8 +10,9 @@ import { formatForLog } from "./ws-log.js";
  */
 function shouldSuppressHeartbeatBroadcast(runId) {
     const runContext = getAgentRunContext(runId);
-    if (!runContext?.isHeartbeat)
+    if (!runContext?.isHeartbeat) {
         return false;
+    }
     try {
         const cfg = loadConfig();
         const visibility = resolveHeartbeatVisibility({ cfg, channel: "webchat" });
@@ -36,23 +37,28 @@ export function createChatRunRegistry() {
     const peek = (sessionId) => chatRunSessions.get(sessionId)?.[0];
     const shift = (sessionId) => {
         const queue = chatRunSessions.get(sessionId);
-        if (!queue || queue.length === 0)
+        if (!queue || queue.length === 0) {
             return undefined;
+        }
         const entry = queue.shift();
-        if (!queue.length)
+        if (!queue.length) {
             chatRunSessions.delete(sessionId);
+        }
         return entry;
     };
     const remove = (sessionId, clientRunId, sessionKey) => {
         const queue = chatRunSessions.get(sessionId);
-        if (!queue || queue.length === 0)
+        if (!queue || queue.length === 0) {
             return undefined;
+        }
         const idx = queue.findIndex((entry) => entry.clientRunId === clientRunId && (sessionKey ? entry.sessionKey === sessionKey : true));
-        if (idx < 0)
+        if (idx < 0) {
             return undefined;
+        }
         const [entry] = queue.splice(idx, 1);
-        if (!queue.length)
+        if (!queue.length) {
             chatRunSessions.delete(sessionId);
+        }
         return entry;
     };
     const clear = () => {
@@ -79,13 +85,69 @@ export function createChatRunState() {
         clear,
     };
 }
-export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRunSeq, chatRunState, resolveSessionKeyForRun, clearAgentRunContext, }) {
+const TOOL_EVENT_RECIPIENT_TTL_MS = 10 * 60 * 1000;
+const TOOL_EVENT_RECIPIENT_FINAL_GRACE_MS = 30 * 1000;
+export function createToolEventRecipientRegistry() {
+    const recipients = new Map();
+    const prune = () => {
+        if (recipients.size === 0) {
+            return;
+        }
+        const now = Date.now();
+        for (const [runId, entry] of recipients) {
+            const cutoff = entry.finalizedAt
+                ? entry.finalizedAt + TOOL_EVENT_RECIPIENT_FINAL_GRACE_MS
+                : entry.updatedAt + TOOL_EVENT_RECIPIENT_TTL_MS;
+            if (now >= cutoff) {
+                recipients.delete(runId);
+            }
+        }
+    };
+    const add = (runId, connId) => {
+        if (!runId || !connId) {
+            return;
+        }
+        const now = Date.now();
+        const existing = recipients.get(runId);
+        if (existing) {
+            existing.connIds.add(connId);
+            existing.updatedAt = now;
+        }
+        else {
+            recipients.set(runId, {
+                connIds: new Set([connId]),
+                updatedAt: now,
+            });
+        }
+        prune();
+    };
+    const get = (runId) => {
+        const entry = recipients.get(runId);
+        if (!entry) {
+            return undefined;
+        }
+        entry.updatedAt = Date.now();
+        prune();
+        return entry.connIds;
+    };
+    const markFinal = (runId) => {
+        const entry = recipients.get(runId);
+        if (!entry) {
+            return;
+        }
+        entry.finalizedAt = Date.now();
+        prune();
+    };
+    return { add, get, markFinal };
+}
+export function createAgentEventHandler({ broadcast, broadcastToConnIds, nodeSendToSession, agentRunSeq, chatRunState, resolveSessionKeyForRun, clearAgentRunContext, toolEventRecipients, }) {
     const emitChatDelta = (sessionKey, clientRunId, seq, text) => {
         chatRunState.buffers.set(clientRunId, text);
         const now = Date.now();
         const last = chatRunState.deltaSentAt.get(clientRunId) ?? 0;
-        if (now - last < 150)
+        if (now - last < 150) {
             return;
+        }
         chatRunState.deltaSentAt.set(clientRunId, now);
         const payload = {
             runId: clientRunId,
@@ -139,23 +201,26 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
         broadcast("chat", payload);
         nodeSendToSession(sessionKey, "chat", payload);
     };
-    const shouldEmitToolEvents = (runId, sessionKey) => {
+    const resolveToolVerboseLevel = (runId, sessionKey) => {
         const runContext = getAgentRunContext(runId);
         const runVerbose = normalizeVerboseLevel(runContext?.verboseLevel);
-        if (runVerbose)
-            return runVerbose === "on";
-        if (!sessionKey)
-            return false;
+        if (runVerbose) {
+            return runVerbose;
+        }
+        if (!sessionKey) {
+            return "off";
+        }
         try {
             const { cfg, entry } = loadSessionEntry(sessionKey);
             const sessionVerbose = normalizeVerboseLevel(entry?.verboseLevel);
-            if (sessionVerbose)
-                return sessionVerbose === "on";
+            if (sessionVerbose) {
+                return sessionVerbose;
+            }
             const defaultVerbose = normalizeVerboseLevel(cfg.agents?.defaults?.verboseDefault);
-            return defaultVerbose === "on";
+            return defaultVerbose ?? "off";
         }
         catch {
-            return false;
+            return "off";
         }
     };
     return (evt) => {
@@ -166,10 +231,17 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
         // Include sessionKey so Control UI can filter tool streams per session.
         const agentPayload = sessionKey ? { ...evt, sessionKey } : evt;
         const last = agentRunSeq.get(evt.runId) ?? 0;
-        if (evt.stream === "tool" && !shouldEmitToolEvents(evt.runId, sessionKey)) {
-            agentRunSeq.set(evt.runId, evt.seq);
-            return;
-        }
+        const isToolEvent = evt.stream === "tool";
+        const toolVerbose = isToolEvent ? resolveToolVerboseLevel(evt.runId, sessionKey) : "off";
+        // Build tool payload: strip result/partialResult unless verbose=full
+        const toolPayload = isToolEvent && toolVerbose !== "full"
+            ? (() => {
+                const data = evt.data ? { ...evt.data } : {};
+                delete data.result;
+                delete data.partialResult;
+                return sessionKey ? { ...evt, sessionKey, data } : { ...evt, data };
+            })()
+            : agentPayload;
         if (evt.seq !== last + 1) {
             broadcast("agent", {
                 runId: evt.runId,
@@ -184,10 +256,26 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
             });
         }
         agentRunSeq.set(evt.runId, evt.seq);
-        broadcast("agent", agentPayload);
+        if (isToolEvent) {
+            // Always broadcast tool events to registered WS recipients with
+            // tool-events capability, regardless of verboseLevel. The verbose
+            // setting only controls whether tool details are sent as channel
+            // messages to messaging surfaces (Telegram, Discord, etc.).
+            const recipients = toolEventRecipients.get(evt.runId);
+            if (recipients && recipients.size > 0) {
+                broadcastToConnIds("agent", toolPayload, recipients);
+            }
+        }
+        else {
+            broadcast("agent", agentPayload);
+        }
         const lifecyclePhase = evt.stream === "lifecycle" && typeof evt.data?.phase === "string" ? evt.data.phase : null;
         if (sessionKey) {
-            nodeSendToSession(sessionKey, "agent", agentPayload);
+            // Send tool events to node/channel subscribers only when verbose is enabled;
+            // WS clients already received the event above via broadcastToConnIds.
+            if (!isToolEvent || toolVerbose !== "off") {
+                nodeSendToSession(sessionKey, "agent", isToolEvent ? toolPayload : agentPayload);
+            }
             if (!isAborted && evt.stream === "assistant" && typeof evt.data?.text === "string") {
                 emitChatDelta(sessionKey, clientRunId, evt.seq, evt.data.text);
             }
@@ -215,6 +303,7 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
             }
         }
         if (lifecyclePhase === "end" || lifecyclePhase === "error") {
+            toolEventRecipients.markFinal(evt.runId);
             clearAgentRunContext(evt.runId);
         }
     };

package/dist/gateway/server-discovery-runtime.js

@@ -1,6 +1,6 @@
 import { startGatewayBonjourAdvertiser } from "../infra/bonjour.js";
 import { pickPrimaryTailnetIPv4, pickPrimaryTailnetIPv6 } from "../infra/tailnet.js";
-import { WIDE_AREA_DISCOVERY_DOMAIN, writeWideAreaGatewayZone } from "../infra/widearea-dns.js";
+import { resolveWideAreaDiscoveryDomain, writeWideAreaGatewayZone } from "../infra/widearea-dns.js";
 import { formatBonjourInstanceName, resolveBonjourCliPath, resolveTailnetDnsHint, } from "./server-discovery.js";
 export async function startGatewayDiscovery(params) {
     let bonjourStop = null;
@@ -40,6 +40,13 @@ export async function startGatewayDiscovery(params) {
         }
     }
     if (params.wideAreaDiscoveryEnabled) {
+        const wideAreaDomain = resolveWideAreaDiscoveryDomain({
+            configDomain: params.wideAreaDiscoveryDomain ?? undefined,
+        });
+        if (!wideAreaDomain) {
+            params.logDiscovery.warn("discovery.wideArea.enabled is true, but no domain was configured; set discovery.wideArea.domain to enable unicast DNS-SD");
+            return { bonjourStop };
+        }
         const tailnetIPv4 = pickPrimaryTailnetIPv4();
         if (!tailnetIPv4) {
             params.logDiscovery.warn("discovery.wideArea.enabled is true, but no Tailscale IPv4 address was found; skipping unicast DNS-SD zone update");
@@ -48,6 +55,7 @@ export async function startGatewayDiscovery(params) {
             try {
                 const tailnetIPv6 = pickPrimaryTailnetIPv6();
                 const result = await writeWideAreaGatewayZone({
+                    domain: wideAreaDomain,
                     gatewayPort: params.port,
                     displayName: formatBonjourInstanceName(params.machineDisplayName),
                     tailnetIPv4,
@@ -58,7 +66,7 @@ export async function startGatewayDiscovery(params) {
                     sshPort,
                     cliPath: resolveBonjourCliPath(),
                 });
-                params.logDiscovery.info(`wide-area DNS-SD ${result.changed ? "updated" : "unchanged"} (${WIDE_AREA_DISCOVERY_DOMAIN} → ${result.zonePath})`);
+                params.logDiscovery.info(`wide-area DNS-SD ${result.changed ? "updated" : "unchanged"} (${wideAreaDomain} → ${result.zonePath})`);
             }
             catch (err) {
                 params.logDiscovery.warn(`wide-area discovery update failed: ${String(err)}`);