feat(08-01): return council task ids without blocking

- make athena_council launch-only and remove internal polling/formatting

- return JSON payload with running task mappings and launch failures

- update tool tests for task-id visibility, filtering, failure reporting, and dedup

src/tools/athena-council/tools.test.ts

@@ -2,7 +2,7 @@
 
 import { describe, expect, test } from "bun:test"
 import type { BackgroundManager } from "../../features/background-agent"
-import { ATHENA_COUNCIL_TOOL_DESCRIPTION_TEMPLATE } from "./constants"
+import type { BackgroundTask } from "../../features/background-agent/types"
 import { createAthenaCouncilTool, filterCouncilMembers } from "./tools"
 
 const mockManager = {
@@ -25,6 +25,27 @@ const configuredMembers = [
   { model: "google/gemini-3-pro" },
 ]
 
+function createRunningTask(id: string): BackgroundTask {
+  return {
+    id,
+    parentSessionID: "session-1",
+    parentMessageID: "message-1",
+    description: `Council member task ${id}`,
+    prompt: "prompt",
+    agent: "athena",
+    status: "running",
+  }
+}
+
+function parseLaunchResult(result: unknown): {
+  launched: number
+  members: Array<{ task_id: string; name: string; model: string; status: string }>
+  failed: Array<{ name: string; model: string; error: string }>
+} {
+  expect(typeof result).toBe("string")
+  return JSON.parse(result as string)
+}
+
 describe("filterCouncilMembers", () => {
   test("returns all members when selection is undefined", () => {
     // #given
@@ -151,4 +172,140 @@ describe("createAthenaCouncilTool", () => {
     // #then
     expect(result).toBe("Unknown council members: unknown-model. Available members: Claude, GPT, google/gemini-3-pro.")
   })
+
+  test("returns launched task_ids and member mapping for configured council", async () => {
+    // #given
+    let launchCount = 0
+    const launchManager = {
+      launch: async () => {
+        launchCount += 1
+        return createRunningTask(`bg-${launchCount}`)
+      },
+      getTask: () => undefined,
+    } as unknown as BackgroundManager
+    const athenaCouncilTool = createAthenaCouncilTool({
+      backgroundManager: launchManager,
+      councilConfig: { members: configuredMembers },
+    })
+
+    // #when
+    const result = await athenaCouncilTool.execute({ question: "How should we proceed?" }, mockToolContext)
+    const parsed = parseLaunchResult(result)
+
+    // #then
+    expect(parsed.launched).toBe(3)
+    expect(parsed.failed).toEqual([])
+    expect(parsed.members).toEqual([
+      {
+        task_id: "bg-1",
+        name: "Claude",
+        model: "anthropic/claude-sonnet-4-5",
+        status: "running",
+      },
+      {
+        task_id: "bg-2",
+        name: "GPT",
+        model: "openai/gpt-5.3-codex",
+        status: "running",
+      },
+      {
+        task_id: "bg-3",
+        name: "google/gemini-3-pro",
+        model: "google/gemini-3-pro",
+        status: "running",
+      },
+    ])
+  })
+
+  test("returns task_ids length matching selected members", async () => {
+    // #given
+    let launchCount = 0
+    const launchManager = {
+      launch: async () => {
+        launchCount += 1
+        return createRunningTask(`bg-${launchCount}`)
+      },
+      getTask: () => undefined,
+    } as unknown as BackgroundManager
+    const athenaCouncilTool = createAthenaCouncilTool({
+      backgroundManager: launchManager,
+      councilConfig: { members: configuredMembers },
+    })
+
+    // #when
+    const result = await athenaCouncilTool.execute(
+      {
+        question: "Who should investigate this?",
+        members: ["GPT", "google/gemini-3-pro"],
+      },
+      mockToolContext
+    )
+    const parsed = parseLaunchResult(result)
+
+    // #then
+    expect(parsed.launched).toBe(2)
+    expect(parsed.members).toHaveLength(2)
+    expect(parsed.members.map((member) => member.name)).toEqual(["GPT", "google/gemini-3-pro"])
+  })
+
+  test("returns failed launches inline while keeping successful task mappings", async () => {
+    // #given
+    let launchCount = 0
+    const launchManager = {
+      launch: async () => {
+        launchCount += 1
+        if (launchCount === 2) {
+          throw new Error("provider outage")
+        }
+
+        return createRunningTask(`bg-${launchCount}`)
+      },
+      getTask: () => undefined,
+    } as unknown as BackgroundManager
+    const athenaCouncilTool = createAthenaCouncilTool({
+      backgroundManager: launchManager,
+      councilConfig: { members: configuredMembers },
+    })
+
+    // #when
+    const result = await athenaCouncilTool.execute({ question: "Any concerns?" }, mockToolContext)
+    const parsed = parseLaunchResult(result)
+
+    // #then
+    expect(parsed.launched).toBe(2)
+    expect(parsed.members).toHaveLength(2)
+    expect(parsed.failed).toHaveLength(1)
+    expect(parsed.failed[0]).toEqual({
+      name: "GPT",
+      model: "openai/gpt-5.3-codex",
+      error: "Launch failed: Error: provider outage",
+    })
+  })
+
+  test("returns dedup error when council is already running in same session", async () => {
+    // #given
+    let resolveLaunch: ((task: BackgroundTask) => void) | undefined
+    const pendingLaunch = new Promise<BackgroundTask>((resolve) => {
+      resolveLaunch = resolve
+    })
+    const launchManager = {
+      launch: async () => pendingLaunch,
+      getTask: () => undefined,
+    } as unknown as BackgroundManager
+    const athenaCouncilTool = createAthenaCouncilTool({
+      backgroundManager: launchManager,
+      councilConfig: { members: [{ model: "openai/gpt-5.3-codex" }] },
+    })
+
+    // #when
+    const firstExecution = athenaCouncilTool.execute({ question: "First run" }, mockToolContext)
+    const secondExecution = await athenaCouncilTool.execute({ question: "Second run" }, mockToolContext)
+
+    resolveLaunch?.(createRunningTask("bg-dedup"))
+    const firstResult = parseLaunchResult(await firstExecution)
+
+    // #then
+    expect(secondExecution).toBe("Council is already running for this session. Wait for the current council execution to complete.")
+    expect(firstResult.launched).toBe(1)
+  })
 })