Coordinator Mode

export function isCoordinatorMode(): boolean {
  if (feature('COORDINATOR_MODE')) {
    return isEnvTruthy(process.env.CLAUDE_CODE_COORDINATOR_MODE)
  }
  return false
}

/**
 * Checks if the current coordinator mode matches the session's stored mode.
 * If mismatched, flips the environment variable so isCoordinatorMode()
 * returns the correct value for the resumed session.
 * Returns a warning message if the mode was switched, or undefined if not.
 */
export function matchSessionMode(
  sessionMode: 'coordinator' | 'normal' | undefined,
): string | undefined {
  if (!sessionMode) return undefined  // old session, no tracking

  const currentIsCoordinator = isCoordinatorMode()
  const sessionIsCoordinator  = sessionMode === 'coordinator'

  if (currentIsCoordinator === sessionIsCoordinator) return undefined

  // Flip the env var — isCoordinatorMode() reads it live, no caching
  if (sessionIsCoordinator) {
    process.env.CLAUDE_CODE_COORDINATOR_MODE = '1'
  } else {
    delete process.env.CLAUDE_CODE_COORDINATOR_MODE
  }

  logEvent('tengu_coordinator_mode_switched', { to: sessionMode })

  return sessionIsCoordinator
    ? 'Entered coordinator mode to match resumed session.'
    : 'Exited coordinator mode to match resumed session.'
}

// Tools hidden from workers even though they are in ASYNC_AGENT_ALLOWED_TOOLS
const INTERNAL_WORKER_TOOLS = new Set([
  TEAM_CREATE_TOOL_NAME,    // 'TeamCreate'
  TEAM_DELETE_TOOL_NAME,    // 'TeamDelete'
  SEND_MESSAGE_TOOL_NAME,   // 'SendMessage'
  SYNTHETIC_OUTPUT_TOOL_NAME,
])

export function getCoordinatorUserContext(
  mcpClients: ReadonlyArray<{ name: string }>,
  scratchpadDir?: string,
): { [k: string]: string } {
  if (!isCoordinatorMode()) return {}

  // Simple mode: workers only get Bash, Read, Edit
  const workerTools = isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE)
    ? [BASH_TOOL_NAME, FILE_READ_TOOL_NAME, FILE_EDIT_TOOL_NAME].sort().join(', ')
    : Array.from(ASYNC_AGENT_ALLOWED_TOOLS)
        .filter(name => !INTERNAL_WORKER_TOOLS.has(name))
        .sort()
        .join(', ')

  let content = `Workers spawned via the Agent tool have access to these tools: ${workerTools}`

  if (mcpClients.length > 0) {
    const serverNames = mcpClients.map(c => c.name).join(', ')
    content += `\n\nWorkers also have access to MCP tools from connected MCP servers: ${serverNames}`
  }

  if (scratchpadDir && isScratchpadGateEnabled()) {
    content += `\n\nScratchpad directory: ${scratchpadDir}\nWorkers can read and write here without permission prompts.`
  }

  return { workerToolsContext: content }
}

You are a coordinator. Your job is to:
- Help the user achieve their goal
- Direct workers to research, implement and verify code changes
- Synthesize results and communicate with the user
- Answer questions directly when possible — don't delegate work that
  you can handle without tools

Every message you send is to the user. Worker results and system
notifications are internal signals, not conversation partners —
never thank or acknowledge them. Summarize new information for
the user as it arrives.

Let me investigate from two angles.

Agent({ description: "Investigate auth bug", subagent_type: "worker",
        prompt: "Find null pointer sources in src/auth/. Report file paths,
                 line numbers, types. Do not modify files." })

Agent({ description: "Research auth test coverage", subagent_type: "worker",
        prompt: "Find all test files for src/auth/. Report gaps around
                 session expiry. Do not modify files." })

Investigating both in parallel — I will report back with findings.

// User request
User: "There's a null pointer in the auth module. Can you fix it?"

// Turn 1 — coordinator launches research workers in parallel
You:
  Let me investigate from two angles.

  Agent({ description: "Investigate auth bug", subagent_type: "worker",
    prompt: "Investigate src/auth/. Find where null pointer exceptions
             could occur around session handling and token validation.
             Report specific file paths, line numbers, and types.
             Do not modify files." })

  Agent({ description: "Research auth tests", subagent_type: "worker",
    prompt: "Find all test files related to src/auth/. Report structure,
             coverage, and gaps around session expiry. Do not modify files." })

  Investigating from two angles — I will report back with findings.

// task-notification from Worker A
User:
  <task-notification>
  <task-id>agent-a1b</task-id>
  <status>completed</status>
  <summary>Agent "Investigate auth bug" completed</summary>
  <result>Found null pointer in src/auth/validate.ts:42. The user field
  on Session (types.ts:15) is undefined when sessions expire but the
  token remains cached. validate() accesses user.id without null check.
  </result>
  </task-notification>

// Turn 2 — synthesize finding, continue same worker with specific spec
You:
  Found the bug — null pointer in validate.ts:42. Still waiting on test coverage.

  SendMessage({ to: "agent-a1b",
    message: "Fix the null pointer in src/auth/validate.ts:42.
              The user field on Session (src/auth/types.ts:15) is
              undefined when sessions expire but the token is still
              cached. Add a null check before user.id access — if
              user is null, return 401 with 'Session expired'.
              Run the auth test suite, commit, report the hash." })

  Fix is in progress. Still waiting for test coverage findings.

// task-notification from Worker B
User:
  <task-notification>
  <task-id>agent-b2c</task-id>
  <status>completed</status>
  <result>Test file: src/auth/__tests__/validate.test.ts. Session expiry
  paths are tested at lines 58 and 72 but only for the happy path —
  no test for expired session + cached token.</result>
  </task-notification>

// Turn 3 — spawn fresh verifier once Worker A reports back
// (Worker A's implementation-heavy context should not contaminate verification)
You:
  Test coverage found: validate.test.ts lacks expired session + cached token cases.
  I will have the verifier add those once the fix lands.

// After Worker A reports fix committed:
You:
  Fix is committed. Launching verification.

  Agent({ description: "Verify auth fix", subagent_type: "worker",
    prompt: "Verify the null-check fix in src/auth/validate.ts:42.
             Add test cases to validate.test.ts (lines 58 and 72 area)
             covering expired session + cached token — expect 401
             with 'Session expired'. Run full auth suite with the
             feature enabled. Investigate any failures — do not dismiss
             as unrelated. Report pass/fail and the updated test hash." })

  Verification in progress.