Answer plain user messages in channels via a channel-anchor wake

A human message in a channel woke agents only through @mentions, DM
counterparts, or prior thread participants - and the flat composer
always sends threadId=null, so typing in #general summoned nobody and
the room stayed silent.

- Track which agents each wake path summoned in one woken set (also
  prevents latent double-wakes between the paths)
- When a non-slash human message in a channel wakes nobody, wake the
  channel's most senior active agent member with an enabled provider
  (c_suite > director > lead > staff, then hire date); they can pull
  teammates in with @mentions
- Log when a channel has no runnable agent so silence is diagnosable
- Integration test: plain #general message wakes the CEO who replies;
  an explicit mention still wakes exactly one agent

tests/integration/channel-anchor.test.ts

@@ -0,0 +1,112 @@
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { DatabaseConnection } from "../../src/main/database/connection";
+import { ChatService } from "../../src/main/services/chat-service";
+import { OnboardingService } from "../../src/main/services/onboarding-service";
+import { ProviderService } from "../../src/main/services/provider-service";
+import { providerAdapters } from "../../src/main/services/provider-adapters";
+import { TaskExecutionService } from "../../src/main/services/task-execution-service";
+import { canonicalMentionHandle } from "../../src/shared/mention-handles";
+import type { AgentTurnResult, ProviderToolTurnInput, ToolCall } from "../../src/main/services/provider-tool-turn";
+
+const testVault = {
+  encryptSecret: (secret: string) => Buffer.from(secret, "utf8"),
+  decryptSecret: (ciphertext: Buffer) => ciphertext.toString("utf8"),
+};
+
+function call(name: string, args: Record<string, unknown>): ToolCall {
+  return { id: `call_${randomUUID()}`, name, arguments: args };
+}
+
+/** CEO answers in the thread the wake prompt names, then finishes. */
+function scriptedCeoReply(): (input: ProviderToolTurnInput) => Promise<AgentTurnResult> {
+  let turn = 0;
+  return async (input: ProviderToolTurnInput): Promise<AgentTurnResult> => {
+    const firstUser = input.messages.find((message) => message.role === "user");
+    const threadId = firstUser ? /thread_id="([^"]+)"/.exec(firstUser.text)?.[1] : undefined;
+    const scripted = turn === 0
+      ? { text: "Answering.", toolCalls: [call("send_message", { channel: "general", body: "Here is where we stand: kickoff is planned.", ...(threadId ? { thread_id: threadId } : {}) })] }
+      : { text: "Done.", toolCalls: [] };
+    turn += 1;
+    return { text: scripted.text, toolCalls: scripted.toolCalls, rawResponseJson: "{}" };
+  };
+}
+
+describe("channel anchor wake", () => {
+  test("a plain user message in a channel wakes the most senior member, who replies", async () => {
+    const connection = new DatabaseConnection(join(tmpdir(), `ac-anchor-${randomUUID()}.db`));
+    const providers = new ProviderService(connection.db, providerAdapters, testVault, undefined, scriptedCeoReply());
+    const onboarding = new OnboardingService({ db: connection.db, saveProviderCredential: (input) => providers.saveCredential(input) });
+    const taskExecution = new TaskExecutionService(connection.db, providers);
+    const chat = new ChatService(connection.db);
+
+    let orgId = "";
+    connection.transaction(() => {
+      orgId = onboarding.bootstrap({
+        companyName: "OrbitOps AI",
+        companyDescription: "AI-run operations company.",
+        employeeName: "Yang",
+        workspacePath: "",
+        executionMode: "ai_ceo",
+        autoApproveHires: true,
+        reviewDeliverables: false,
+        goalTitle: "Stand up a service business.",
+        goalDescription: "Win the first customers.",
+        providerKey: "openai",
+        providerSecret: "sk-test-key",
+        providerModel: "gpt-5.4",
+      }).orgId;
+    });
+
+    const employee = connection.db.prepare("select id from employees where org_id = ?").get(orgId) as { id: string };
+    const general = connection.db.prepare("select id from chat_spaces where org_id = ? and name = 'general'").get(orgId) as { id: string };
+    const ceo = connection.db.prepare("select id from agents where org_id = ? and role_level = 'c_suite'").get(orgId) as { id: string };
+
+    // A plain message: no @mention, no thread. Somebody must still answer.
+    connection.transaction(() => {
+      chat.sendMessage({
+        orgId,
+        spaceId: general.id,
+        threadId: null,
+        senderType: "employee",
+        senderId: employee.id,
+        bodyMd: "Where do we stand on the goal?",
+        attachmentFileIds: [],
+      });
+    });
+
+    const wake = connection.db.prepare(
+      "select id, agent_id, state, trigger from task_runs where org_id = ? and trigger = 'chat_mention'",
+    ).all(orgId) as Array<{ id: string; agent_id: string; state: string; trigger: string }>;
+    expect(wake).toHaveLength(1);
+    expect(wake[0]).toMatchObject({ agent_id: ceo.id, state: "queued" });
+
+    // The woken CEO answers in #general.
+    await taskExecution.executeRun(orgId, wake[0].id);
+    const reply = connection.db.prepare(
+      "select body_md from chat_messages where org_id = ? and space_id = ? and sender_type = 'agent' and sender_id = ?",
+    ).get(orgId, general.id, ceo.id) as { body_md: string } | undefined;
+    expect(reply?.body_md).toContain("Here is where we stand");
+
+    // An explicit @mention wakes only the mentioned agent - no anchor duplicate.
+    connection.transaction(() => {
+      chat.sendMessage({
+        orgId,
+        spaceId: general.id,
+        threadId: null,
+        senderType: "employee",
+        senderId: employee.id,
+        bodyMd: `@${canonicalMentionHandle("CEO")} thanks, keep me posted.`,
+        attachmentFileIds: [],
+      });
+    });
+    const runsAfterMention = connection.db.prepare(
+      "select count(*) as count from task_runs where org_id = ? and trigger = 'chat_mention'",
+    ).get(orgId) as { count: number };
+    expect(runsAfterMention.count).toBe(2);
+
+    connection.close();
+  });
+});