feat: replace subagent and skills with unified summon extension

[tlongwell-block]

Introduces the summon extension to unify goose's delegation and knowledge-loading capabilities.

New Tools

Tool	Purpose	Example
load	Discover sources or inject knowledge	load() lists all, load(source: "rust-patterns") loads content
delegate	Run task in isolated subagent	delegate(instructions: "...") or delegate(source: "review", async: true)

Features

• Source discovery: Recipes, skills, agents from local/global paths with priority resolution
• Async execution: Background tasks with turn tracking and MOIM status reporting
• Unprefixed tools: Cleaner tool names without extension__ prefix

Removed

• subagent_tool.rs, skills_extension.rs, builtin_skills/ - replaced by summon

Closes #6202

[DOsinga]

I haven't looked at the details here, but this feels like the right way to do this.

[tlongwell-block]

/goose

[github-actions]

Summary: This PR unifies goose's delegation (subagent) and knowledge-loading (skills) capabilities into a single "summon" extension with load and delegate tools. The architectural approach is sound - consolidating related functionality and introducing unprefixed tools for cleaner ergonomics. However, there are some implementation concerns around test coverage and resource management.

🟡 Warnings

1. Test coverage reduced for tool resolution (extension_manager.rs:1704-1770 deleted)

   The old test_get_client_for_tool tests covered important edge cases: unicode tool names, multiple underscores in names, and various prefixing scenarios. These tests were deleted but the new resolve_tool function has different (and more complex) resolution logic with no equivalent test coverage.

   // Old tests removed:
   // - test handling of "__client" prefixes
   // - test "__cli__ent__" (multiple underscores)
   // - unicode handling

   The new resolution has two paths: (1) prefix-based lookup and (2) metadata-based fallback. Both deserve test coverage.

2. Completed tasks accumulate unbounded (summon_extension.rs)

   The completed_tasks HashMap only gets entries removed when a user calls load(task_id). Long-running sessions that spawn many background tasks but forget to retrieve results will accumulate memory:

   pub struct CompletedTask {
       pub id: String,
       pub description: String,
       pub result: Result<String, String>,  // Could be large
       pub turns_taken: u32,
       pub duration: Duration,
   }

   Consider adding a TTL or max capacity with LRU eviction.

3. Tool name collision silently drops tools (extension_manager.rs:936-948)

   When two extensions expose unprefixed tools with the same name, the second one is silently skipped with only a warning:

   if seen_names.contains(&tool_name) {
       warn!(
           tool = %tool_name,
           extension = %ext_name,
           "Duplicate tool name - skipping"
       );
       continue;
   }

   This is reasonable behavior, but the warning may be missed. Consider surfacing this in the MOIM or system prompt if it happens, as it could cause user confusion when a tool doesn't behave as expected.

🟢 Suggestions

1. Source discovery errors are silently ignored (various scan_* methods)

   All scan_recipes_dir, scan_skills_dir, scan_agents_dir methods silently ignore read_dir failures. While this is often fine (directories may not exist), it could mask permission issues:

   let entries = match std::fs::read_dir(dir) {
       Ok(e) => e,
       Err(_) => return,  // All errors ignored
   };

   Consider at least debug-level logging for non-NotFound errors.

2. is_session_id validation is loose (summon_extension.rs)

   The function checks if a string looks like a task ID by matching a timestamp prefix pattern. This works but could theoretically match user-provided source names that happen to look like timestamps:

   fn is_session_id(s: &str) -> bool {
       let parts: Vec<&str> = s.split('-').collect();
       // checks for timestamp-like prefix
   }

   A more robust approach might be to track known task IDs explicitly.

✅ Highlights

• Good deduplication strategy: Using HashSet<String> in discover_filesystem_sources ensures sources from higher-priority directories (local → global) take precedence cleanly.

• Proper cancellation handling: Background tasks properly receive and respect cancellation tokens, and the last_activity tracking enables idle detection.

• Clean tool ownership tracking: Storing goose_extension in tool metadata is a good pattern that allows resolution without relying on naming conventions.

• Subagent recursion prevention: The check if !is_subagent { tools.push(self.create_delegate_tool()); } correctly prevents infinite delegation chains.

• Helpful MOIM integration: The get_moim implementation provides clear status on background tasks with formatted duration and turn counts.

---

Review generated by goose