@automagik/omni 2.260409.3 → 2.260409.5

package/dist/commands/done.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"done.d.ts","sourceRoot":"","sources":["../../src/commands/done.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2HpC,wBAAgB,iBAAiB,IAAI,OAAO,CA0C3C"}
+{"version":3,"file":"done.d.ts","sourceRoot":"","sources":["../../src/commands/done.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmIpC,wBAAgB,iBAAiB,IAAI,OAAO,CA0C3C"}

package/dist/commands/turns.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Turns Commands — Admin turn management
+ *
+ * omni turns list [--status open|done|timeout] [--instance <id>] [--chat <id>] [--agent <id>] [--limit N]
+ * omni turns get <id>
+ * omni turns close <id> [--reason <text>]
+ * omni turns close-all --confirm [--reason <text>]
+ * omni turns stats
+ */
+import { Command } from 'commander';
+export declare function createTurnsCommand(): Command;
+//# sourceMappingURL=turns.d.ts.map

package/dist/commands/turns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turns.d.ts","sourceRoot":"","sources":["../../src/commands/turns.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,wBAAgB,kBAAkB,IAAI,OAAO,CAiG5C"}

package/dist/index.js

@@ -76815,16 +76815,82 @@ function createOmniClient(config) {
       }
     },
     turns: {
-      async close(body) {
+      async close(body, extraHeaders) {
         const resp = await apiFetch(`${baseUrl}/api/v2/turns/close`, {
           method: "POST",
-          headers: { "Content-Type": "application/json" },
+          headers: { "Content-Type": "application/json", ...extraHeaders },
           body: JSON.stringify(body)
         });
         const json = await resp.json();
         if (!resp.ok)
           throw OmniApiError.from(json, resp.status);
         return json?.data ?? {};
+      },
+      async list(params) {
+        const qs = new URLSearchParams;
+        if (params?.status)
+          qs.set("status", params.status);
+        if (params?.instanceId)
+          qs.set("instanceId", params.instanceId);
+        if (params?.chatId)
+          qs.set("chatId", params.chatId);
+        if (params?.agentId)
+          qs.set("agentId", params.agentId);
+        if (params?.limit !== undefined)
+          qs.set("limit", String(params.limit));
+        if (params?.offset !== undefined)
+          qs.set("offset", String(params.offset));
+        const query = qs.toString();
+        const url = `${baseUrl}/api/v2/turns${query ? `?${query}` : ""}`;
+        const resp = await apiFetch(url);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        return json?.data ?? { items: [], total: 0, limit: 50, offset: 0 };
+      },
+      async get(id) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/${id}`);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Turn not found", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async forceClose(id, reason) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/${id}/close`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ reason })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Turn not found or already closed", "NOT_FOUND", undefined, 404);
+        return json.data;
+      },
+      async bulkClose(reason) {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/close-all`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ confirm: true, reason })
+        });
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Bulk close failed", "INTERNAL_ERROR", undefined, 500);
+        return json.data;
+      },
+      async stats() {
+        const resp = await apiFetch(`${baseUrl}/api/v2/turns/stats`);
+        const json = await resp.json();
+        if (!resp.ok)
+          throw OmniApiError.from(json, resp.status);
+        if (!json?.data)
+          throw new OmniApiError("Stats unavailable", "INTERNAL_ERROR", undefined, 500);
+        return json.data;
       }
     },
     agents: {
@@ -76906,7 +76972,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "@automagik/omni",
-  version: "2.260409.3",
+  version: "2.260409.5",
   description: "LLM-optimized CLI for Omni",
   type: "module",
   bin: {
@@ -80700,7 +80766,13 @@ function getMediaType(path) {
 }
 async function closeTurn(client, action, successMsg, reason) {
   try {
-    const result = await client.turns.close({ action, reason });
+    const turnId = process.env.OMNI_TURN_ID;
+    const extraHeaders = {};
+    if (process.env.OMNI_INSTANCE)
+      extraHeaders["x-omni-instance"] = process.env.OMNI_INSTANCE;
+    if (process.env.OMNI_CHAT)
+      extraHeaders["x-omni-chat"] = process.env.OMNI_CHAT;
+    const result = await client.turns.close({ action, reason, turnId }, extraHeaders);
     if (result.alreadyClosed) {
       success(`${successMsg} Turn already closed (idempotent).`);
     } else {
@@ -80790,7 +80862,7 @@ function createDoneCommand() {
       return handleMedia(client, ctxWithMessage, options.media, options.caption);
     if (text)
       return handleText(client, ctxWithMessage, text);
-    error('Specify what to do: omni done "text", omni done --media <file>, omni done --react <emoji>, or omni done --skip');
+    return handleSkip(client, options.reason);
   });
 }
 
@@ -95594,6 +95666,78 @@ function createTtsCommand() {
   return tts;
 }
 
+// src/commands/turns.ts
+init_output();
+function formatDuration2(startedAt, closedAt) {
+  const start = new Date(startedAt).getTime();
+  const end = closedAt ? new Date(closedAt).getTime() : Date.now();
+  const ms = end - start;
+  if (ms < 1000)
+    return `${ms}ms`;
+  if (ms < 60000)
+    return `${Math.round(ms / 1000)}s`;
+  return `${Math.round(ms / 60000)}m`;
+}
+function createTurnsCommand() {
+  const cmd = new Command("turns").description("Admin turn management");
+  cmd.command("list").description("List turns with optional filters").option("--status <status>", "Filter by status (open, done, timeout)").option("--instance <id>", "Filter by instance ID").option("--chat <id>", "Filter by chat ID").option("--agent <id>", "Filter by agent ID").option("--limit <n>", "Max results (default 50)", "50").option("--offset <n>", "Offset for pagination (default 0)", "0").action(async (opts) => {
+    const client = getClient();
+    const result = await client.turns.list({
+      status: opts.status,
+      instanceId: opts.instance,
+      chatId: opts.chat,
+      agentId: opts.agent,
+      limit: Number(opts.limit),
+      offset: Number(opts.offset)
+    });
+    const rows = result.items.map((t) => ({
+      id: t.id.slice(0, 8),
+      status: t.status,
+      chat: t.chatId.length > 20 ? `${t.chatId.slice(0, 20)}\u2026` : t.chatId,
+      agent: t.agentId.slice(0, 8),
+      duration: formatDuration2(t.startedAt, t.closedAt),
+      nudges: t.nudgeCount,
+      msgs: t.messagesSent
+    }));
+    list(rows, {
+      emptyMessage: "No turns found.",
+      rawData: result.items
+    });
+    if (getCurrentFormat() !== "json") {
+      dim(`Total: ${result.total} | Showing ${result.offset + 1}\u2013${result.offset + result.items.length}`);
+    }
+  });
+  cmd.command("get").description("Get a single turn by ID").argument("<id>", "Turn ID").action(async (id) => {
+    const client = getClient();
+    const turn = await client.turns.get(id);
+    data(turn);
+  });
+  cmd.command("close").description("Admin force-close a turn").argument("<id>", "Turn ID to close").option("--reason <text>", "Close reason").action(async (id, opts) => {
+    const client = getClient();
+    const result = await client.turns.forceClose(id, opts.reason);
+    success(`Turn ${result.turnId} closed`, result);
+  });
+  cmd.command("close-all").description("Bulk close all open turns (requires --confirm)").option("--confirm", "Confirm bulk close").option("--reason <text>", "Close reason").action(async (opts) => {
+    if (!opts.confirm) {
+      error("Bulk close requires --confirm flag to proceed.");
+    }
+    const client = getClient();
+    const result = await client.turns.bulkClose(opts.reason);
+    success(result.message, result);
+  });
+  cmd.command("stats").description("Show aggregate turn metrics").action(async () => {
+    const client = getClient();
+    const stats = await client.turns.stats();
+    data({
+      openCount: stats.openCount,
+      totalCount: stats.totalCount,
+      avgDurationMs: stats.avgDurationMs,
+      timeoutRate: `${(stats.timeoutRate * 100).toFixed(1)}%`
+    });
+  });
+  return cmd;
+}
+
 // src/commands/update.ts
 import { createInterface as createInterface4 } from "readline";
 init_source();
@@ -96538,6 +96682,12 @@ var COMMANDS = [
     helpGroup: "Management",
     helpDescription: "Webhook management"
   },
+  {
+    create: createTurnsCommand,
+    category: "advanced",
+    helpGroup: "Management",
+    helpDescription: "Admin turn management (list, close, stats)"
+  },
   {
     create: createStatusCommand,
     category: "core",

package/dist/server/index.js

@@ -222829,7 +222829,7 @@ var init_sentry_scrub = __esm(() => {
 var require_package8 = __commonJS((exports, module) => {
   module.exports = {
     name: "@omni/api",
-    version: "2.260409.3",
+    version: "2.260409.5",
     type: "module",
     exports: {
       ".": {
@@ -238212,6 +238212,11 @@ var init_scopes = __esm(() => {
     "PATCH /settings": "settings:write",
     "DELETE /settings/:key": "settings:write",
     "GET /settings/:key/history": "settings:read",
+    "GET /turns": "turns:admin",
+    "GET /turns/stats": "turns:admin",
+    "GET /turns/:id": "turns:admin",
+    "POST /turns/:id/close": "turns:admin",
+    "POST /turns/close-all": "turns:admin",
     "POST /turns/close": "turns:close",
     "GET /webhook-sources": "webhooks:read",
     "GET /webhook-sources/:id": "webhooks:read",
@@ -349377,6 +349382,63 @@ class TurnService {
   async incrementMessages(turnId) {
     await this.db.update(turns).set({ messagesSent: sql`${turns.messagesSent} + 1` }).where(eq(turns.id, turnId));
   }
+  async list(options) {
+    const conditions3 = [];
+    if (options.status)
+      conditions3.push(eq(turns.status, options.status));
+    if (options.instanceId)
+      conditions3.push(eq(turns.instanceId, options.instanceId));
+    if (options.chatId)
+      conditions3.push(eq(turns.chatId, options.chatId));
+    if (options.agentId)
+      conditions3.push(eq(turns.agentId, options.agentId));
+    const where = conditions3.length > 0 ? and2(...conditions3) : undefined;
+    const [items, [totalRow]] = await Promise.all([
+      this.db.select().from(turns).where(where).orderBy(sql`${turns.startedAt} DESC`).limit(options.limit).offset(options.offset),
+      this.db.select({ count: count2() }).from(turns).where(where)
+    ]);
+    return { items, total: totalRow?.count ?? 0 };
+  }
+  async stats() {
+    const [row] = await this.db.select({
+      totalCount: count2(),
+      openCount: sql`count(*) filter (where ${turns.status} = 'open')`,
+      timeoutCount: sql`count(*) filter (where ${turns.status} = 'timeout')`,
+      avgDurationMs: sql`coalesce(avg(extract(epoch from (${turns.closedAt} - ${turns.startedAt})) * 1000) filter (where ${turns.closedAt} is not null), 0)`
+    }).from(turns);
+    const total = row?.totalCount ?? 0;
+    const timeoutCount = Number(row?.timeoutCount ?? 0);
+    return {
+      openCount: Number(row?.openCount ?? 0),
+      totalCount: total,
+      avgDurationMs: Math.round(Number(row?.avgDurationMs ?? 0)),
+      timeoutRate: total > 0 ? timeoutCount / total : 0
+    };
+  }
+  async forceClose(turnId, reason) {
+    const now = new Date;
+    const [closed] = await this.db.update(turns).set({
+      status: "done",
+      action: "skip",
+      closedAt: now,
+      closedReason: reason ?? "admin force-close"
+    }).where(and2(eq(turns.id, turnId), eq(turns.status, "open"))).returning();
+    if (closed) {
+      log83.info("Turn force-closed by admin", { turnId });
+    }
+    return closed ?? null;
+  }
+  async bulkClose(reason) {
+    const now = new Date;
+    const closed = await this.db.update(turns).set({
+      status: "done",
+      action: "skip",
+      closedAt: now,
+      closedReason: reason ?? "admin bulk close"
+    }).where(eq(turns.status, "open")).returning({ id: turns.id });
+    log83.info("Bulk close completed", { closedCount: closed.length });
+    return closed.length;
+  }
 }
 var log83;
 var init_turns = __esm(() => {
@@ -362013,11 +362075,14 @@ var init_messages5 = __esm(() => {
       });
     }
     const resolvedTo = await resolveRecipient(to, instance4.channel, services);
+    let fromMe = false;
     const chat2 = await services.chats.findByExternalIdSmart(instanceId, resolvedTo);
     if (chat2) {
       const target = await services.messages.getByExternalId(chat2.id, messageId);
       if (!target) {
         log90.warn("Target message not found in DB, sending reaction anyway", { messageId, chatId: chat2.id });
+      } else {
+        fromMe = target.isFromMe === true;
       }
     }
     const outgoingMessage = {
@@ -362026,7 +362091,8 @@ var init_messages5 = __esm(() => {
         type: "reaction",
         emoji,
         targetMessageId: messageId
-      }
+      },
+      metadata: { fromMe }
     };
     const result = await plugin6.sendMessage(instanceId, outgoingMessage);
     if (!result.success) {
@@ -363490,16 +363556,51 @@ var init_turn_events = __esm(() => {
 });
 
 // ../api/src/routes/v2/turns.ts
-var turnsRoutes, closeTurnSchema;
+function requireAdmin(c) {
+  const keyData = c.get("apiKey");
+  if (!keyData) {
+    return c.json({ error: { code: "UNAUTHORIZED", message: "API key required" } }, 401);
+  }
+  if (!ApiKeyService.scopeAllows(keyData.scopes, "turns:admin")) {
+    return c.json({ error: { code: "FORBIDDEN", message: "Master key or turns:admin scope required" } }, 403);
+  }
+  return null;
+}
+async function resolveOpenTurn(services, keyId, turnId, headerInstanceId, headerChatId) {
+  const byKey = await services.turns.getOpenByApiKey(keyId);
+  if (byKey)
+    return byKey;
+  if (turnId) {
+    const candidate = await services.turns.getById(turnId);
+    if (candidate && candidate.status === "open")
+      return candidate;
+  }
+  let instanceId = headerInstanceId;
+  let chatId = headerChatId;
+  if (!instanceId || !chatId) {
+    const fullKey = await services.apiKeys.getById(keyId);
+    if (fullKey) {
+      instanceId = instanceId ?? fullKey.contextInstanceId ?? undefined;
+      chatId = chatId ?? fullKey.contextChatId ?? undefined;
+    }
+  }
+  if (instanceId && chatId) {
+    return services.turns.getOpen(instanceId, chatId);
+  }
+  return null;
+}
+var turnsRoutes, closeTurnSchema, listQuerySchema16, adminForceCloseSchema, bulkCloseSchema;
 var init_turns2 = __esm(() => {
   init_dist6();
   init_dist2();
   init_zod();
+  init_api_keys();
   init_turn_events();
   turnsRoutes = new Hono2;
   closeTurnSchema = exports_external.object({
     action: exports_external.enum(["message", "react", "skip"]).describe("How the turn was closed"),
-    reason: exports_external.string().optional().describe("Close reason (for skip action)")
+    reason: exports_external.string().optional().describe("Close reason (for skip action)"),
+    turnId: exports_external.string().uuid().optional().describe("Explicit turn ID to close (fallback when API key has no associated turn)")
   });
   turnsRoutes.post("/close", zValidator("json", closeTurnSchema), async (c) => {
     const keyData = c.get("apiKey");
@@ -363508,12 +363609,12 @@ var init_turns2 = __esm(() => {
     }
     const body = c.req.valid("json");
     const services = c.get("services");
-    const openTurn = await services.turns.getOpenByApiKey(keyData.id);
+    const openTurn = await resolveOpenTurn(services, keyData.id, body.turnId, c.req.header("x-omni-instance"), c.req.header("x-omni-chat"));
     if (!openTurn) {
       return c.json({
         data: {
           alreadyClosed: true,
-          message: "No open turn for this API key"
+          message: "No open turn found"
         }
       });
     }
@@ -363551,10 +363652,145 @@ var init_turns2 = __esm(() => {
       }
     });
   });
+  listQuerySchema16 = exports_external.object({
+    status: exports_external.enum(["open", "done", "timeout"]).optional(),
+    instanceId: exports_external.string().uuid().optional(),
+    chatId: exports_external.string().optional(),
+    agentId: exports_external.string().uuid().optional(),
+    limit: exports_external.coerce.number().int().min(1).max(200).default(50),
+    offset: exports_external.coerce.number().int().min(0).default(0)
+  });
+  adminForceCloseSchema = exports_external.object({
+    reason: exports_external.string().optional()
+  });
+  bulkCloseSchema = exports_external.object({
+    confirm: exports_external.boolean(),
+    reason: exports_external.string().optional()
+  });
+  turnsRoutes.get("/", zValidator("query", listQuerySchema16), async (c) => {
+    const denied = requireAdmin(c);
+    if (denied)
+      return denied;
+    const query = c.req.valid("query");
+    const services = c.get("services");
+    const { items, total } = await services.turns.list({
+      status: query.status,
+      instanceId: query.instanceId,
+      chatId: query.chatId,
+      agentId: query.agentId,
+      limit: query.limit,
+      offset: query.offset
+    });
+    return c.json({
+      data: {
+        items: items.map((t) => ({
+          id: t.id,
+          instanceId: t.instanceId,
+          chatId: t.chatId,
+          messageId: t.messageId,
+          agentId: t.agentId,
+          apiKeyId: t.apiKeyId,
+          status: t.status,
+          action: t.action,
+          nudgeCount: t.nudgeCount,
+          messagesSent: t.messagesSent,
+          startedAt: t.startedAt.toISOString(),
+          lastActivityAt: t.lastActivityAt.toISOString(),
+          closedAt: t.closedAt?.toISOString() ?? null,
+          closedReason: t.closedReason
+        })),
+        total,
+        limit: query.limit,
+        offset: query.offset
+      }
+    });
+  });
+  turnsRoutes.get("/stats", async (c) => {
+    const denied = requireAdmin(c);
+    if (denied)
+      return denied;
+    const services = c.get("services");
+    const stats = await services.turns.stats();
+    return c.json({ data: stats });
+  });
+  turnsRoutes.get("/:id", async (c) => {
+    const denied = requireAdmin(c);
+    if (denied)
+      return denied;
+    const services = c.get("services");
+    const turn = await services.turns.getById(c.req.param("id"));
+    if (!turn) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Turn not found" } }, 404);
+    }
+    return c.json({
+      data: {
+        id: turn.id,
+        instanceId: turn.instanceId,
+        chatId: turn.chatId,
+        messageId: turn.messageId,
+        agentId: turn.agentId,
+        apiKeyId: turn.apiKeyId,
+        status: turn.status,
+        action: turn.action,
+        nudgeCount: turn.nudgeCount,
+        messagesSent: turn.messagesSent,
+        startedAt: turn.startedAt.toISOString(),
+        lastActivityAt: turn.lastActivityAt.toISOString(),
+        closedAt: turn.closedAt?.toISOString() ?? null,
+        closedReason: turn.closedReason,
+        metadata: turn.metadata
+      }
+    });
+  });
+  turnsRoutes.post("/:id/close", zValidator("json", adminForceCloseSchema), async (c) => {
+    const denied = requireAdmin(c);
+    if (denied)
+      return denied;
+    const services = c.get("services");
+    const body = c.req.valid("json");
+    const turnId = c.req.param("id");
+    const closed = await services.turns.forceClose(turnId, body.reason);
+    if (!closed) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Turn not found or already closed" } }, 404);
+    }
+    const durationMs = closed.closedAt ? closed.closedAt.getTime() - closed.startedAt.getTime() : Date.now() - closed.startedAt.getTime();
+    publishTurnDone(closed.instanceId, closed.chatId, {
+      turnId: closed.id,
+      action: "skip",
+      reason: body.reason ?? "admin force-close",
+      duration: durationMs,
+      nudgeCount: closed.nudgeCount,
+      messagesSent: closed.messagesSent
+    });
+    return c.json({
+      data: {
+        turnId: closed.id,
+        status: closed.status,
+        closedAt: closed.closedAt?.toISOString() ?? null
+      }
+    });
+  });
+  turnsRoutes.post("/close-all", zValidator("json", bulkCloseSchema), async (c) => {
+    const denied = requireAdmin(c);
+    if (denied)
+      return denied;
+    const body = c.req.valid("json");
+    if (!body.confirm) {
+      return c.json({ error: { code: "CONFIRMATION_REQUIRED", message: "Set confirm: true to bulk-close all open turns" } }, 400);
+    }
+    const services = c.get("services");
+    const closedCount = await services.turns.bulkClose(body.reason);
+    return c.json({
+      data: {
+        closedCount,
+        message: `Closed ${closedCount} open turn(s)`
+      }
+    });
+  });
 });
 
 // ../api/src/routes/v2/webhooks.ts
-var webhooksRoutes, createWebhookSourceSchema, updateWebhookSourceSchema, listQuerySchema16, triggerEventSchema;
+var webhooksRoutes, createWebhookSourceSchema, updateWebhookSourceSchema, listQuerySchema17, triggerEventSchema;
 var init_webhooks3 = __esm(() => {
   init_dist6();
   init_dist2();
@@ -363568,10 +363804,10 @@ var init_webhooks3 = __esm(() => {
     enabled: exports_external.boolean().default(true).describe("Whether source is enabled")
   });
   updateWebhookSourceSchema = createWebhookSourceSchema.partial();
-  listQuerySchema16 = exports_external.object({
+  listQuerySchema17 = exports_external.object({
     enabled: exports_external.coerce.boolean().optional()
   });
-  webhooksRoutes.get("/webhook-sources", zValidator("query", listQuerySchema16), async (c) => {
+  webhooksRoutes.get("/webhook-sources", zValidator("query", listQuerySchema17), async (c) => {
     const { enabled } = c.req.valid("query");
     const services = c.get("services");
     const sources = await services.webhooks.list({ enabled });
@@ -366652,10 +366888,13 @@ async function dispatchViaTurnBasedProvider(services, instance4, provider, trigg
     agentId: agentRecord.id,
     apiKeyId: scopedKey.id
   });
+  const contextChat = await services.chats.findByExternalIdSmart(instance4.id, chatId);
+  const contextChatId = contextChat?.id ?? null;
+  const contextMsg = contextChat && messageId ? await services.messages.getByExternalId(contextChat.id, messageId) : null;
   await services.apiKeys.update(scopedKey.id, {
     contextInstanceId: instance4.id,
-    contextChatId: chatId,
-    contextMessageId: messageId || null
+    contextChatId,
+    contextMessageId: contextMsg?.id ?? null
   });
   publishTurnOpen(instance4.id, chatId, {
     turnId: turn.id,
@@ -367432,7 +367671,8 @@ async function processReactionTrigger(services, baseInstance, payload, metadata,
   const externalChatId = payload.chatId;
   const chat2 = await services.chats.findByExternalIdSmart(baseInstance.id, externalChatId);
   const internalChatId = chat2?.id;
-  const { instance: instance4, routeId: _routeId } = await resolveEffectiveInstance(services, db2, baseInstance, internalChatId, metadata.personId);
+  const reactionPersonId = await resolvePersonId(services, channel4, baseInstance.id, payload.from, metadata.personId);
+  const { instance: instance4, routeId: _routeId } = await resolveEffectiveInstance(services, db2, baseInstance, internalChatId, reactionPersonId);
   log98.info("Dispatching reaction trigger", {
     instanceId: instance4.id,
     chatId: externalChatId,
@@ -367445,7 +367685,8 @@ async function processReactionTrigger(services, baseInstance, payload, metadata,
   try {
     const provider = await getAgentProvider(services, instance4, db2);
     if (provider) {
-      const senderName2 = await services.agentRunner.getSenderName(metadata.personId, undefined);
+      const effectivePersonId = reactionPersonId ?? metadata.personId;
+      const senderName2 = await services.agentRunner.getSenderName(effectivePersonId, undefined);
       const sessionId = computeSessionId(instance4.agentSessionStrategy ?? "per_chat", payload.from, externalChatId);
       const trigger = {
         traceId: metadata.traceId,
@@ -367459,7 +367700,7 @@ async function processReactionTrigger(services, baseInstance, payload, metadata,
         },
         sender: {
           platformUserId: payload.from,
-          personId: metadata.personId,
+          personId: effectivePersonId,
           displayName: senderName2
         },
         content: {
@@ -367902,7 +368143,9 @@ async function setupAgentDispatcher(eventBus, services, db2) {
           return;
         const traceId = metadata.traceId ?? generateCorrelationId("trc");
         const chat2 = await services.chats.findByExternalIdSmart(instance4.id, payload.chatId);
-        const { instance: resolved, routeId } = await resolveEffectiveInstance(services, db2, instance4, chat2?.id, metadata.personId);
+        const channel4 = metadata.channelType ?? "whatsapp";
+        const earlyPersonId = await resolvePersonId(services, channel4, instance4.id, payload.from, metadata.personId);
+        const { instance: resolved, routeId } = await resolveEffectiveInstance(services, db2, instance4, chat2?.id, earlyPersonId);
         const debounceConfig = getDebounceConfig(resolved);
         const isGroupChat2 = payload.chatId.includes("@g.us");
         const effectiveDebounceConfig = isGroupChat2 && debounceConfig.groupMs != null ? {
@@ -368007,7 +368250,8 @@ async function setupAgentDispatcher(eventBus, services, db2) {
         if (!baseInstance?.agentId)
           return;
         const chat2 = await services.chats.findByExternalIdSmart(metadata.instanceId, payload.chatId);
-        const { instance: resolved } = await resolveEffectiveInstance(services, db2, baseInstance, chat2?.id, metadata.personId);
+        const typingPersonId = metadata.personId;
+        const { instance: resolved } = await resolveEffectiveInstance(services, db2, baseInstance, chat2?.id, typingPersonId);
         const debounceConfig = getDebounceConfig(resolved);
         if (debounceConfig.restartOnTyping) {
           debouncer.onUserTyping(metadata.instanceId, payload.chatId, debounceConfig);
@@ -369609,7 +369853,7 @@ class TurnMonitor {
     log102.info("Turn force-closed (timeout)", { turnId, duration, nudgeCount });
   }
 }
-var log102, NUDGE_THRESHOLD_MS = 60000, FALLBACK_THRESHOLD_MS = 300000, TIMEOUT_THRESHOLD_MS = 900000, POLL_INTERVAL_MS2 = 1e4;
+var log102, NUDGE_THRESHOLD_MS = 120000, FALLBACK_THRESHOLD_MS = 600000, TIMEOUT_THRESHOLD_MS = 1800000, POLL_INTERVAL_MS2 = 1e4;
 var init_turn_monitor = __esm(() => {
   init_src();
   init_turn_events();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automagik/omni",
-  "version": "2.260409.3",
+  "version": "2.260409.5",
   "description": "LLM-optimized CLI for Omni",
   "type": "module",
   "bin": {