Autonomous Agents：自组织团队

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

export function matchSessionMode(
  sessionMode: 'coordinator' | 'normal' | undefined,
): string | undefined {
  const currentIsCoordinator = isCoordinatorMode()
  const sessionIsCoordinator = sessionMode === 'coordinator'

  if (currentIsCoordinator === sessionIsCoordinator) {
    return undefined
  }

  // 翻转环境变量，让 isCoordinatorMode() 实时匹配
  if (sessionIsCoordinator) {
    process.env.CLAUDE_CODE_COORDINATOR_MODE = '1'
  } else {
    delete process.env.CLAUDE_CODE_COORDINATOR_MODE
  }
  // ...
}

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

  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 (scratchpadDir && isScratchpadGateEnabled()) {
    content += `\n\nScratchpad directory: ${scratchpadDir}\n`
      + 'Workers can read and write here without permission prompts.'
  }

  return { workerToolsContext: content }
}

export type DreamPhase = 'starting' | 'updating'

export type DreamTaskState = TaskStateBase & {
  type: 'dream'
  phase: DreamPhase
  sessionsReviewing: number          // 正在回顾多少个 session
  filesTouched: string[]             // 被修改的文件路径（不完整）
  turns: DreamTurn[]                 // 最近 30 轮的摘要
  abortController?: AbortController  // 用于取消
  priorMtime: number                 // 用于 kill 时回滚锁
}

const MAX_TURNS = 30

export function addDreamTurn(
  taskId: string,
  turn: DreamTurn,
  touchedPaths: string[],
  setAppState: SetAppState,
): void {
  updateTaskState<DreamTaskState>(taskId, setAppState, task => {
    const seen = new Set(task.filesTouched)
    const newTouched = touchedPaths.filter(p => !seen.has(p) && seen.add(p))
    // 空 turn 且没有新文件 → 跳过，避免无意义重渲染
    if (turn.text === '' && turn.toolUseCount === 0 && newTouched.length === 0) {
      return task
    }
    return {
      ...task,
      phase: newTouched.length > 0 ? 'updating' : task.phase,
      filesTouched: newTouched.length > 0
        ? [...task.filesTouched, ...newTouched]
        : task.filesTouched,
      turns: task.turns.slice(-(MAX_TURNS - 1)).concat(turn),
    }
  })
}

async kill(taskId, setAppState) {
  let priorMtime: number | undefined
  updateTaskState<DreamTaskState>(taskId, setAppState, task => {
    if (task.status !== 'running') return task
    task.abortController?.abort()
    priorMtime = task.priorMtime
    return { ...task, status: 'killed', endTime: Date.now(), notified: true }
  })
  // 回滚锁的 mtime，让下次 session 可以重试
  if (priorMtime !== undefined) {
    await rollbackConsolidationLock(priorMtime)
  }
}

export function completeDreamTask(taskId, setAppState): void {
  // notified: true immediately — dream 没有 model-facing 通知路径
  // 它是纯 UI 展示，eviction 需要 terminal + notified
  updateTaskState<DreamTaskState>(taskId, setAppState, task => ({
    ...task, status: 'completed', endTime: Date.now(), notified: true,
  }))
}

// memoryTypes.ts
export const MEMORY_TYPES = ['user', 'feedback', 'project', 'reference'] as const

const result = await runForkedAgent({
  promptMessages: [createUserMessage({ content: userPrompt })],
  cacheSafeParams,
  canUseTool,
  querySource: 'extract_memories',
  forkLabel: 'extract_memories',
  skipTranscript: true,   // 不记录到 transcript，避免和主线程竞争
  maxTurns: 5,            // 硬上限，防止验证兔子洞
})

// 闭包内的可变状态
let lastMemoryMessageUuid: string | undefined

function countModelVisibleMessagesSince(
  messages: Message[],
  sinceUuid: string | undefined,
): number {
  if (sinceUuid === null || sinceUuid === undefined) {
    return count(messages, isModelVisibleMessage)
  }
  let foundStart = false
  let n = 0
  for (const message of messages) {
    if (!foundStart) {
      if (message.uuid === sinceUuid) { foundStart = true }
      continue
    }
    if (isModelVisibleMessage(message)) { n++ }
  }
  // 游标 UUID 不存在（被 context compaction 删除）→ 回退到全量计数
  if (!foundStart) {
    return count(messages, isModelVisibleMessage)
  }
  return n
}

if (hasMemoryWritesSince(messages, lastMemoryMessageUuid)) {
  // 主 agent 已经写了 → 跳过，推进游标
  lastMemoryMessageUuid = lastMessage.uuid
  return
}

let inProgress = false
let pendingContext: { context: REPLHookContext; ... } | undefined

// 如果正在运行，暂存最新上下文
if (inProgress) {
  pendingContext = { context, appendSystemMessage }
  return
}

// runExtraction 的 finally 块
finally {
  inProgress = false
  const trailing = pendingContext
  pendingContext = undefined
  if (trailing) {
    // trailing run 使用推进后的游标，只处理新增消息
    await runExtraction({ ...trailing, isTrailingRun: true })
  }
}

function opener(newMessageCount: number, existingMemories: string): string {
  return [
    `You are now acting as the memory extraction subagent.`,
    `Analyze the most recent ~${newMessageCount} messages above...`,
    `Available tools: Read, Grep, Glob, read-only Bash, Edit/Write for memory dir only.`,
    `You have a limited turn budget. Efficient strategy:`,
    `  turn 1 — parallel Read all files you might update`,
    `  turn 2 — parallel Write/Edit all changes`,
    // 预注入已有记忆目录清单
    existingMemories.length > 0
      ? `## Existing memory files\n${existingMemories}\nCheck before writing — update, don't duplicate.`
      : '',
  ].join('\n')
}