Files
LLeMbas-CLI/src/tool/registry.ts
T
HomerandClaude Opus 5.5 6ec95fbd66
ci / check (push) Waiting to run
Teams in the CLI (harness spec 3.2.0, team.md)
The four team tools (tool/team_tools.ts) on the rules of team/team.ts,
driven from real turns by team/runtime.ts:

- Members run on the subagent job machinery (app.ts spawn with `member`):
  background, unattended, their own prompt from blocks/team_member.md
  (the whole of team_lead.md for one with lead: true), team_send and
  team_read (team_add and team_stop for one that leads). Not jobs to the
  model: job_list and the job_* tools skip them; a client over the link
  still sees them as subagent jobs named "<name>: <role>".
- The room: messages and reports with their marks, delivered at the next
  step boundary or waking a finished member or the idle lead; report
  posts to the manager.
- A manager's work calls answer the refusal before the permission check,
  by risk class (an MCP tool by its readOnlyHint); the tool list is
  unchanged. job_stop and reading bash stay.
- Slots: the lead waits for one before its turn (Esc stops the wait);
  members wait in order; task helpers in a team count toward the size
  and hold a slot; job_send restarting a helper is refused when full.
- The offer is decided with the prompt and kept with it: a resumed
  session takes it from its kept tool list.
- The size: agents.min/max settings, refused outside 1 <= min <= max <=
  cap, kept across /new and resume; said in a note on the first message,
  after a change, after a compaction and a rewind.
- TUI: /team (tree and room, size, stop a member, dialogs for both), an
  "agents" row beside the effort in /effort, "team n/max" in the status
  bar. /team works over ACP too.

tests/team.test.ts runs a lead, a member and its report through the app.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 09:08:52 +00:00

79 lines
2.3 KiB
TypeScript

import { applyPatchTool } from "./apply_patch.ts"
import { bashTool } from "./bash.ts"
import { jobListTool, jobOutputTool, jobSendTool, jobStopTool, reportTool } from "./job_tools.ts"
import { editTool } from "./edit.ts"
import { multieditTool } from "./multiedit.ts"
import { askUserTool } from "./ask_user.ts"
import { readTool } from "./read.ts"
import { globTool, grepTool, listTool } from "./search.ts"
import { viewImageTool } from "./view_image.ts"
import { planSubmitTool } from "./plan_submit.ts"
import { planUpdateTool } from "./plan_update.ts"
import { planWriteTool } from "./plan_write.ts"
import { taskTool } from "./task.ts"
import { teamAddTool, teamReadTool, teamSendTool, teamStopTool } from "./team_tools.ts"
import { decisionsTool, tasksTool } from "./project_tools.ts"
import { webFetchTool, webSearchTool } from "./web.ts"
import { memoryTool } from "./memory.ts"
import { sessionSearchTool } from "./session_search.ts"
import { skillManageTool, skillsListTool, skillViewTool } from "./skills.ts"
import { settingsTool } from "./settings.ts"
import { showTool } from "./show.ts"
import { recallTool } from "./recall.ts"
import { knowledgeGetTool, knowledgeSearchTool, noteManageTool, notesSearchTool, noteViewTool } from "./library.ts"
import type { Tool } from "./tool.ts"
import { writeTool } from "./write.ts"
export const BUILTIN_TOOLS: Tool[] = [
readTool,
writeTool,
editTool,
multieditTool,
applyPatchTool,
globTool,
grepTool,
listTool,
bashTool,
jobOutputTool,
jobListTool,
jobStopTool,
jobSendTool,
webSearchTool,
webFetchTool,
taskTool,
// Spec 3.2.0: a team (team.md), offered where the model serves two requests at once.
teamAddTool,
teamSendTool,
teamReadTool,
teamStopTool,
planWriteTool,
planUpdateTool,
tasksTool,
decisionsTool,
askUserTool,
planSubmitTool,
memoryTool,
sessionSearchTool,
notesSearchTool,
noteViewTool,
noteManageTool,
knowledgeSearchTool,
knowledgeGetTool,
skillsListTool,
skillViewTool,
skillManageTool,
settingsTool,
viewImageTool,
showTool,
recallTool,
// Offered to subagents only (the spec's `offered: subagent`; app.ts SUBAGENT_ONLY).
reportTool,
] as Tool[]
export function toolMap(tools: Tool[] = BUILTIN_TOOLS): Map<string, Tool> {
return new Map(tools.map((t) => [t.name, t]))
}
export { canonicalToolNames, resolveCall } from "./names.ts"