Add set_complexity to recap MCP

[acreeger]

Summary

Add a set_complexity tool to the recap MCP server that captures the assessed complexity of the current task. This provides important context for users to understand the scope of work.

Complexity Levels

• trivial - Quick fix, single change
• simple - Straightforward implementation, few files
• complex - Multi-step, architectural decisions, significant scope

MCP Tool

server.registerTool(
  'set_complexity',
  {
    title: 'Set Complexity',
    description: 'Set the assessed complexity of the current task',
    inputSchema: {
      complexity: z.enum(['trivial', 'simple', 'complex']).describe('Task complexity level'),
      reason: z.string().optional().describe('Brief explanation for the assessment'),
    },
  },
  // ...
)

Schema Addition

{
  "filePath": "...",
  "goal": null,
  "complexity": {
    "level": "complex",
    "reason": "Multiple files affected, requires architectural changes",
    "timestamp": "2025-12-15T10:23:45Z"
  },
  "entries": [...],
  "artifacts": [...]
}

Prompt Updates

Update prompts to:

1. Call set_complexity when complexity is determined or changes
2. Do NOT use add_entry to report complexity - use the dedicated tool

Related

• Part of the Loom Context Panel feature set
• Extends Loom Recap MCP Server #346 (Recap MCP Server)
• Coordinate prompt updates with Update prompts to use Loom Recap MCP #347

[acreeger]

VS Code display: iloom-ai/iloom-vscode#47

[acreeger]

Complexity Assessment

Classification: TRIVIAL

Metrics:

• Estimated files affected: 3
• Estimated lines of code: 80
• Breaking changes: No
• Database migrations: No
• Cross-cutting changes: No
• File architecture quality: Good (recap-server.ts 295 LOC, recap-types.ts 84 LOC - both well-structured)
• Overall risk level: Low

Reasoning: This is a straightforward additive feature following the established pattern of existing tools (set_goal, add_entry). The implementation requires registering one new MCP tool in recap-server.ts (~30 lines), adding type definitions in recap-types.ts (~20 lines), and updating agent template files with tool references (~30 lines across 7 files). No behavioral changes to existing functionality, no architectural concerns, and low risk.

[acreeger]

Combined Analysis & Plan - Issue #352

Executive Summary

Add a set_complexity tool to the recap MCP server following the established pattern of set_goal. This enables agents to record task complexity assessments (trivial/simple/complex) that persist in the recap file and display in the VS Code Loom Context Panel.

Questions and Key Decisions

Question	Answer
Should complexity-evaluator use set_complexity instead of add_entry?	Yes - issue explicitly states "do NOT use add_entry for complexity reporting"
Should get_recap output include complexity?	Yes - schema shows complexity as top-level field in RecapFile
Which agents need prompt updates?	iloom-issue-complexity-evaluator.md (determines complexity) AND orchestrator prompts (issue-prompt.txt, regular-prompt.txt, pr-prompt.txt) for complexity routing

Implementation Overview

High-Level Execution Phases

1. Types: Add RecapComplexity type and complexity field to RecapFile/RecapOutput
2. Server: Register set_complexity tool following set_goal pattern
3. CLI: Update recap.ts to include complexity in output
4. Prompts: Update complexity-evaluator template AND orchestrator prompts (issue-prompt.txt, regular-prompt.txt, pr-prompt.txt)

Quick Stats

• 7 files to modify
• 0 new files to create
• 0 files to delete
• Dependencies: None

---

Complete Analysis & Implementation Details (click to expand)

Research Findings

Problem Space

• Problem: Complexity assessments are logged via add_entry which mixes them with insights/decisions; dedicated tool enables structured display
• Architectural context: Follows existing pattern of set_goal (single-write, overwrites existing value)
• Edge cases: Multiple set_complexity calls should overwrite (same as set_goal behavior)

Codebase Research

• Entry point: recap-server.ts:113-135 - set_goal tool registration pattern to follow
• Dependencies: recap-types.ts defines all types; recap.ts CLI command uses types for output
• Similar patterns: set_goal at line 113-135 is exact pattern to replicate; add_artifact at 175-231 shows outputSchema with multiple fields
• Orchestrator prompts: issue-prompt.txt, regular-prompt.txt, pr-prompt.txt all have Loom Recap sections (lines 23-46) that need set_complexity added

Affected Files

• /src/mcp/recap-types.ts:1-85 - Add RecapComplexity type, update RecapFile and RecapOutput interfaces
• /src/mcp/recap-server.ts:113-279 - Add set_complexity tool registration, update get_recap outputSchema
• /src/commands/recap.ts:60-86 - Include complexity in CLI output
• /templates/agents/iloom-issue-complexity-evaluator.md:13-26 - Add set_complexity to Loom Recap section
• /templates/prompts/issue-prompt.txt:23-46 - Add set_complexity to Loom Recap section with routing guidance
• /templates/prompts/regular-prompt.txt:23-46 - Add set_complexity to Loom Recap section with routing guidance
• /templates/prompts/pr-prompt.txt:23-44 - Add set_complexity to Loom Recap section

Integration Points

• RecapFile.complexity consumed by get_recap tool (line 263-278)
• RecapOutput.complexity consumed by VS Code extension (via JSON output)
• CLI command uses RecapOutput type (line 64)
• Orchestrator prompts route to TRIVIAL/SIMPLE/COMPLEX workflows based on complexity

---

Implementation Plan

Phase 1: Add Types (recap-types.ts)

1. /src/mcp/recap-types.ts:13 - After RecapArtifactType

Change: Add RecapComplexityLevel type

// Add after line 13 (after RecapArtifactType)
export type RecapComplexityLevel = 'trivial' | 'simple' | 'complex'

2. /src/mcp/recap-types.ts:24 - After RecapArtifact interface

Change: Add RecapComplexity interface

// Add after line 24 (after RecapArtifact interface closing brace)
/** Complexity assessment for the current task */
export interface RecapComplexity {
  level: RecapComplexityLevel
  reason?: string
  timestamp: string
}

3. /src/mcp/recap-types.ts:34-38 - Update RecapFile interface

Change: Add optional complexity field

// Update RecapFile to include complexity (line ~37, before entries)
export interface RecapFile {
  goal?: string | null
  complexity?: RecapComplexity | null  // NEW
  entries?: RecapEntry[]
  artifacts?: RecapArtifact[]
}

4. /src/mcp/recap-types.ts:40-46 - Update RecapOutput interface

Change: Add complexity field (non-optional, defaults to null in output)

// Update RecapOutput to include complexity
export interface RecapOutput {
  filePath: string
  goal: string | null
  complexity: RecapComplexity | null  // NEW
  entries: RecapEntry[]
  artifacts: RecapArtifact[]
}

5. /src/mcp/recap-types.ts:85 - End of file

Change: Add input/output types for set_complexity tool

// Add at end of file
/** Input for set_complexity tool */
export interface SetComplexityInput {
  complexity: RecapComplexityLevel
  reason?: string
}

/** Output for set_complexity tool */
export interface SetComplexityOutput {
  success: true
  timestamp: string
}

---

Phase 2: Register Tool (recap-server.ts)

6. /src/mcp/recap-server.ts:17 - Update import

Change: Add RecapComplexity to import

// Update line 17 to include RecapComplexity
import type { RecapFile, RecapEntry, RecapOutput, RecapArtifact, RecapComplexity } from './recap-types.js'

7. /src/mcp/recap-server.ts:136 - After set_goal tool (line 135)

Change: Register set_complexity tool following set_goal pattern

// Add after line 135 (after set_goal closing parenthesis)
// Register set_complexity tool
server.registerTool(
  'set_complexity',
  {
    title: 'Set Complexity',
    description: 'Set the assessed complexity of the current task',
    inputSchema: {
      complexity: z.enum(['trivial', 'simple', 'complex']).describe('Task complexity level'),
      reason: z.string().optional().describe('Brief explanation for the assessment'),
    },
    outputSchema: {
      success: z.literal(true),
      timestamp: z.string(),
    },
  },
  async ({ complexity, reason }) => {
    const filePath = getRecapFilePath()
    const recap = await readRecapFile(filePath)
    const timestamp = new Date().toISOString()
    recap.complexity = { level: complexity, reason, timestamp }
    await writeRecapFile(filePath, recap)
    const result = { success: true as const, timestamp }
    return {
      content: [{ type: 'text' as const, text: JSON.stringify(result) }],
      structuredContent: result,
    }
  }
)

8. /src/mcp/recap-server.ts:240-261 - Update get_recap outputSchema

Change: Add complexity to outputSchema

// Find outputSchema in get_recap (around line 240-261)
// Add after goal schema (line ~243):
complexity: z.object({
  level: z.enum(['trivial', 'simple', 'complex']),
  reason: z.string().optional(),
  timestamp: z.string(),
}).nullable(),

9. /src/mcp/recap-server.ts:268-273 - Update get_recap result builder

Change: Include complexity in result

// Update result building (around line 268-273)
const result: RecapOutput = {
  filePath,
  goal: recap.goal ?? defaultGoal,
  complexity: recap.complexity ?? null,  // NEW
  entries: recap.entries ?? [],
  artifacts: recap.artifacts ?? [],
}

---

Phase 3: Update CLI (recap.ts)

10. /src/commands/recap.ts:61-64 - Update result building

Change: Include complexity in RecapOutput

// Update lines 61-64
const goal = recap.goal ?? null
const complexity = recap.complexity ?? null  // NEW
const entries = recap.entries ?? []
const artifacts = recap.artifacts ?? []
const result: RecapOutput = { filePath, goal, complexity, entries, artifacts }

11. /src/commands/recap.ts:74-76 - Update human-readable output

Change: Add complexity output after goal

// Add after line 74 (Goal output), before Entries output
// eslint-disable-next-line no-console
console.log(`Complexity: ${complexity ? `${complexity.level}${complexity.reason ? ` - ${complexity.reason}` : ''}` : '(not set)'}`)

---

Phase 4: Update Agent Prompt (iloom-issue-complexity-evaluator.md)

12. /templates/agents/iloom-issue-complexity-evaluator.md:13-26 - Update Loom Recap section

Change: Add set_complexity tool reference and update guidance

Current lines 13-26:

## Loom Recap

The recap panel helps users stay oriented without reading all your output. Capture key discoveries using the Recap MCP tools:
- `recap.get_recap` - Check existing entries to avoid duplicates
- `recap.add_entry` - Log with type: `insight`, `risk`, or `assumption`
- `recap.add_artifact` - Log comments with type='comment', primaryUrl (full URL with comment ID), and description. Re-calling with the same primaryUrl will update the existing entry.

**Log these:**
- **insight**: Complexity factor discoveries - "Change requires coordinating updates across 5 TypeScript interfaces"
- **risk**: Implementation concerns - "Large god-object file (2000+ LOC) will make changes error-prone"
- **assumption**: Scope estimates - "Assuming existing test patterns can be followed without new test infrastructure"

**Never log** workflow status, complexity classifications, or routine metric observations.

Replace with:

## Loom Recap

The recap panel helps users stay oriented without reading all your output. Use the Recap MCP tools:
- `recap.set_complexity` - **REQUIRED**: Call this when you determine the complexity classification
- `recap.get_recap` - Check existing entries to avoid duplicates
- `recap.add_entry` - Log with type: `insight`, `risk`, or `assumption`
- `recap.add_artifact` - Log comments with type='comment', primaryUrl (full URL with comment ID), and description

**IMPORTANT**: Use `set_complexity` (not `add_entry`) for complexity assessments:

recap.set_complexity({ complexity: 'simple', reason: 'Few files, low risk' })

**Log these with add_entry:**
- **insight**: Complexity factor discoveries - "Change requires coordinating updates across 5 TypeScript interfaces"
- **risk**: Implementation concerns - "Large god-object file (2000+ LOC) will make changes error-prone"
- **assumption**: Scope estimates - "Assuming existing test patterns can be followed without new test infrastructure"

**Never log** workflow status or routine metric observations.

---

Phase 5: Update Orchestrator Prompts (NEW)

These orchestrator prompts need to call set_complexity when routing to different workflows based on complexity.

13. /templates/prompts/issue-prompt.txt:34-38 - Add set_complexity to Loom Recap tools list

Change: Add recap.set_complexity tool after recap.set_goal

Current lines 34-38:

Use these Recap MCP tools:
- `recap.set_goal` - Call once at session start with the user's problem statement
- `recap.get_recap` - Call before adding entries to check what's already captured
- `recap.add_entry` - Call with type (decision/insight/risk/assumption) and concise content
- `recap.add_artifact` - After creating/updating comments, issues, or PRs, log them with type, primaryUrl, and description. Duplicates with the same primaryUrl will be replaced.

Replace with:

Use these Recap MCP tools:
- `recap.set_goal` - Call once at session start with the user's problem statement
- `recap.set_complexity` - Call when complexity is confirmed at ROUTING DECISION POINT (trivial/simple/complex)
- `recap.get_recap` - Call before adding entries to check what's already captured
- `recap.add_entry` - Call with type (decision/insight/risk/assumption) and concise content
- `recap.add_artifact` - After creating/updating comments, issues, or PRs, log them with type, primaryUrl, and description. Duplicates with the same primaryUrl will be replaced.

14. /templates/prompts/issue-prompt.txt:424-449 - Add set_complexity call to ROUTING DECISION POINT

Change: Add recap.set_complexity call in each complexity branch

Current lines 424-449 (ROUTING DECISION POINT section):

**ROUTING DECISION POINT - Complexity-Based Workflow Selection:**

After STEP 1.5 completes and complexity is confirmed, determine which workflow path to follow:

**Check the confirmed complexity:**

**IF TRIVIAL complexity confirmed:**
1. Display to user: "Using TRIVIAL workflow: Skipping analysis and planning, proceeding directly to implementation"
2. Mark todo #8 as completed
3. Mark todos #9, #10, #11, #12, #13, #14, and #15 as completed (analysis/planning steps that will not execute)
4. Skip directly to **STEP 4** (Implementation Phase)

**IF SIMPLE complexity confirmed:**
1. Display to user: "✓ Using SIMPLE workflow: Combined analysis and planning via @agent-iloom-issue-analyze-and-plan, then implementation"
2. Mark todo #8 as completed
3. Mark todos #10, #11, #12, #13, #14, and #15 as completed (COMPLEX workflow steps that will not execute)
4. Skip to **STEP 2-SIMPLE** (Combined Analysis and Planning Phase)
5. Note: After STEP 2-SIMPLE completes, skip separate analysis (STEP 2) and planning (STEP 3) phases, go directly to implementation (STEP 4)

**IF COMPLEX complexity confirmed:**
1. Display to user: "✓ Using COMPLEX workflow: Separate analysis, planning, and implementation phases"
2. Mark todo #8 as completed
3. Mark todo #9 as completed (SIMPLE workflow step that will not execute)
4. Continue to **STEP 2** (Analysis Phase) above
5. Follow normal workflow through STEP 2, STEP 3, and STEP 4

Replace with:

**ROUTING DECISION POINT - Complexity-Based Workflow Selection:**

After STEP 1.5 completes and complexity is confirmed, determine which workflow path to follow:

**Check the confirmed complexity:**

**IF TRIVIAL complexity confirmed:**
1. Call `recap.set_complexity({ complexity: 'trivial', reason: '[brief reason from evaluator]' })`
2. Display to user: "Using TRIVIAL workflow: Skipping analysis and planning, proceeding directly to implementation"
3. Mark todo #8 as completed
4. Mark todos #9, #10, #11, #12, #13, #14, and #15 as completed (analysis/planning steps that will not execute)
5. Skip directly to **STEP 4** (Implementation Phase)

**IF SIMPLE complexity confirmed:**
1. Call `recap.set_complexity({ complexity: 'simple', reason: '[brief reason from evaluator]' })`
2. Display to user: "✓ Using SIMPLE workflow: Combined analysis and planning via @agent-iloom-issue-analyze-and-plan, then implementation"
3. Mark todo #8 as completed
4. Mark todos #10, #11, #12, #13, #14, and #15 as completed (COMPLEX workflow steps that will not execute)
5. Skip to **STEP 2-SIMPLE** (Combined Analysis and Planning Phase)
6. Note: After STEP 2-SIMPLE completes, skip separate analysis (STEP 2) and planning (STEP 3) phases, go directly to implementation (STEP 4)

**IF COMPLEX complexity confirmed:**
1. Call `recap.set_complexity({ complexity: 'complex', reason: '[brief reason from evaluator]' })`
2. Display to user: "✓ Using COMPLEX workflow: Separate analysis, planning, and implementation phases"
3. Mark todo #8 as completed
4. Mark todo #9 as completed (SIMPLE workflow step that will not execute)
5. Continue to **STEP 2** (Analysis Phase) above
6. Follow normal workflow through STEP 2, STEP 3, and STEP 4

**Note:** If the user reclassifies complexity (changes from evaluator's assessment), call `set_complexity` with the user's confirmed classification.

15. /templates/prompts/regular-prompt.txt:34-38 - Add set_complexity to Loom Recap tools list

Change: Add recap.set_complexity tool after recap.set_goal

Current lines 34-38:

Use these Recap MCP tools:
- `recap.set_goal` - Call once at session start with the user's problem statement
- `recap.get_recap` - Call before adding entries to check what's already captured
- `recap.add_entry` - Call with type (decision/insight/risk/assumption) and concise content
- `recap.add_artifact` - After creating/updating comments, issues, or PRs, log them with type, primaryUrl, and description. Duplicates with the same primaryUrl will be replaced.

Replace with:

Use these Recap MCP tools:
- `recap.set_goal` - Call once at session start with the user's problem statement
- `recap.set_complexity` - Call when complexity is confirmed at ROUTING DECISION POINT (trivial/simple/complex)
- `recap.get_recap` - Call before adding entries to check what's already captured
- `recap.add_entry` - Call with type (decision/insight/risk/assumption) and concise content
- `recap.add_artifact` - After creating/updating comments, issues, or PRs, log them with type, primaryUrl, and description. Duplicates with the same primaryUrl will be replaced.

16. /templates/prompts/regular-prompt.txt:305-328 - Add set_complexity call to ROUTING DECISION POINT

Change: Add recap.set_complexity call in each complexity branch

Current lines 305-328 (ROUTING DECISION POINT section):

**ROUTING DECISION POINT - Complexity-Based Workflow Selection:**

After STEP 2 (Complexity Evaluation) completes and complexity is confirmed, determine which workflow path to follow:

**Check the confirmed complexity:**

**IF TRIVIAL complexity confirmed:**
1. Display to user: "Using TRIVIAL workflow: Skipping analysis and planning, proceeding directly to implementation"
2. Mark todos #9, #10, #11, #12, #13, #14, #15, and #16 as completed (analysis and planning steps that will not execute)
3. Skip directly to **STEP 5** (Implementation Phase)
4. Note: TRIVIAL tasks are straightforward enough that they don't need analysis or planning

**IF SIMPLE complexity confirmed:**
1. Display to user: "Using SIMPLE workflow: Combined analysis and planning via @agent-iloom-issue-analyze-and-plan, then implementation"
2. Mark todos #9, #11, #12, #13, #14, #15, and #16 as completed (TRIVIAL and COMPLEX workflow steps that will not execute)
3. Skip to **STEP 3-SIMPLE** (Combined Analysis and Planning Phase)
4. Note: After STEP 3-SIMPLE completes, skip separate analysis and planning phases, go directly to implementation

**IF COMPLEX complexity confirmed:**
1. Display to user: "Using COMPLEX workflow: Separate analysis, planning, and implementation phases"
2. Mark todos #9 and #10 as completed (TRIVIAL and SIMPLE workflow steps that will not execute)
3. Continue to **STEP 3** (Analysis Phase)
4. Follow normal workflow through STEP 3, STEP 4, and STEP 5

Replace with:

**ROUTING DECISION POINT - Complexity-Based Workflow Selection:**

After STEP 2 (Complexity Evaluation) completes and complexity is confirmed, determine which workflow path to follow:

**Check the confirmed complexity:**

**IF TRIVIAL complexity confirmed:**
1. Call `recap.set_complexity({ complexity: 'trivial', reason: '[brief reason from evaluator]' })`
2. Display to user: "Using TRIVIAL workflow: Skipping analysis and planning, proceeding directly to implementation"
3. Mark todos #9, #10, #11, #12, #13, #14, #15, and #16 as completed (analysis and planning steps that will not execute)
4. Skip directly to **STEP 5** (Implementation Phase)
5. Note: TRIVIAL tasks are straightforward enough that they don't need analysis or planning

**IF SIMPLE complexity confirmed:**
1. Call `recap.set_complexity({ complexity: 'simple', reason: '[brief reason from evaluator]' })`
2. Display to user: "Using SIMPLE workflow: Combined analysis and planning via @agent-iloom-issue-analyze-and-plan, then implementation"
3. Mark todos #9, #11, #12, #13, #14, #15, and #16 as completed (TRIVIAL and COMPLEX workflow steps that will not execute)
4. Skip to **STEP 3-SIMPLE** (Combined Analysis and Planning Phase)
5. Note: After STEP 3-SIMPLE completes, skip separate analysis and planning phases, go directly to implementation

**IF COMPLEX complexity confirmed:**
1. Call `recap.set_complexity({ complexity: 'complex', reason: '[brief reason from evaluator]' })`
2. Display to user: "Using COMPLEX workflow: Separate analysis, planning, and implementation phases"
3. Mark todos #9 and #10 as completed (TRIVIAL and SIMPLE workflow steps that will not execute)
4. Continue to **STEP 3** (Analysis Phase)
5. Follow normal workflow through STEP 3, STEP 4, and STEP 5

**Note:** If the user reclassifies complexity (changes from evaluator's assessment), call `set_complexity` with the user's confirmed classification.

17. /templates/prompts/pr-prompt.txt:34-38 - Add set_complexity to Loom Recap tools list

Change: Add recap.set_complexity tool after recap.set_goal

Current lines 34-38:

Use these Recap MCP tools:
- `recap.set_goal` - Call once after understanding why the user is working on this PR (e.g., "Review PR for security concerns", "Fix failing tests")
- `recap.get_recap` - Call before adding entries to check what's already captured
- `recap.add_entry` - Call with type (decision/insight/risk/assumption) and concise content
- `recap.add_artifact` - After creating/updating comments, issues, or PRs, log them with type, primaryUrl, and description. Duplicates with the same primaryUrl will be replaced.

Replace with:

Use these Recap MCP tools:
- `recap.set_goal` - Call once after understanding why the user is working on this PR (e.g., "Review PR for security concerns", "Fix failing tests")
- `recap.set_complexity` - Call when task complexity is assessed (trivial/simple/complex)
- `recap.get_recap` - Call before adding entries to check what's already captured
- `recap.add_entry` - Call with type (decision/insight/risk/assumption) and concise content
- `recap.add_artifact` - After creating/updating comments, issues, or PRs, log them with type, primaryUrl, and description. Duplicates with the same primaryUrl will be replaced.

---

Detailed Execution Order

Phase 1: Types

1. Add RecapComplexityLevel type after line 13 in recap-types.ts -> Verify: TypeScript compiles
2. Add RecapComplexity interface after line 24 -> Verify: TypeScript compiles
3. Update RecapFile interface to include complexity field -> Verify: TypeScript compiles
4. Update RecapOutput interface to include complexity field -> Verify: TypeScript compiles
5. Add SetComplexityInput and SetComplexityOutput types at end of file -> Verify: TypeScript compiles

Phase 2: Server

6. Update import to include RecapComplexity -> Verify: No import errors
7. Add set_complexity tool registration after line 135 -> Verify: TypeScript compiles
8. Update get_recap outputSchema to include complexity -> Verify: TypeScript compiles
9. Update get_recap result to include complexity -> Verify: TypeScript compiles

Phase 3: CLI

10. Update result building to include complexity -> Verify: TypeScript compiles
11. Add complexity to human-readable output -> Verify: CLI displays complexity

Phase 4: Agent Prompt

12. Update complexity-evaluator template Loom Recap section -> Verify: File saved correctly

Phase 5: Orchestrator Prompts

13. Update issue-prompt.txt Loom Recap tools list (line 34-38) -> Verify: File saved correctly
14. Update issue-prompt.txt ROUTING DECISION POINT (line 424-449) -> Verify: File saved correctly
15. Update regular-prompt.txt Loom Recap tools list (line 34-38) -> Verify: File saved correctly
16. Update regular-prompt.txt ROUTING DECISION POINT (line 305-328) -> Verify: File saved correctly
17. Update pr-prompt.txt Loom Recap tools list (line 34-38) -> Verify: File saved correctly

Final Verification

• Run pnpm build -> Verify: Build succeeds
• Run pnpm test -> Verify: Existing tests pass
• Manual test: Start MCP server, call set_complexity, call get_recap -> Verify: Complexity persists and returns

Dependencies and Configuration

None

[acreeger]

Implementation Complete - Issue #352

Summary

Added set_complexity tool to the recap MCP server following the established set_goal pattern. Complexity assessments (trivial/simple/complex) now persist in the recap file and display in both CLI output and get_recap MCP tool output.

Changes Made

• src/mcp/recap-types.ts: Added RecapComplexityLevel, RecapComplexity, SetComplexityInput, SetComplexityOutput types; updated RecapFile and RecapOutput interfaces
• src/mcp/recap-server.ts: Registered set_complexity tool; added complexity to get_recap outputSchema and result
• src/commands/recap.ts: Added complexity display to CLI human-readable output
• templates/agents/iloom-issue-complexity-evaluator.md: Added set_complexity as REQUIRED tool
• templates/prompts/issue-prompt.txt: Added set_complexity to tools list and ROUTING DECISION POINT
• templates/prompts/regular-prompt.txt: Added set_complexity to tools list and ROUTING DECISION POINT
• templates/prompts/pr-prompt.txt: Added set_complexity to tools list

Validation Results

• Build: Passed
• Typecheck: Passed
• Tests: 3013 passed, 1 skipped
• Lint: Passed

---

Detailed Changes by File (click to expand)

Files Modified

src/mcp/recap-types.ts

Changes: Added complexity-related types

• Added RecapComplexityLevel = 'trivial' | 'simple' | 'complex'
• Added RecapComplexity interface with level, optional reason, and timestamp
• Updated RecapFile to include optional complexity field
• Updated RecapOutput to include complexity field
• Added SetComplexityInput and SetComplexityOutput interfaces

src/mcp/recap-server.ts

Changes: Registered new MCP tool and updated get_recap output

• Added set_complexity tool registration following set_goal pattern
• Added complexity schema to get_recap outputSchema
• Added complexity to result in get_recap handler

src/commands/recap.ts

Changes: Added complexity to CLI output

• Added complexity variable extraction from recap file
• Added complexity display line in human-readable format

templates/agents/iloom-issue-complexity-evaluator.md

Changes: Updated Loom Recap section to use set_complexity

• Added recap.set_complexity as REQUIRED tool
• Added usage example for set_complexity
• Updated guidance to use dedicated tool instead of add_entry

templates/prompts/issue-prompt.txt

Changes: Added set_complexity to tools and routing

• Added recap.set_complexity to Loom Recap tools list
• Added set_complexity calls at ROUTING DECISION POINT for each complexity branch

templates/prompts/regular-prompt.txt

Changes: Added set_complexity to tools and routing

• Added recap.set_complexity to Loom Recap tools list
• Added set_complexity calls at ROUTING DECISION POINT for each complexity branch

templates/prompts/pr-prompt.txt

Changes: Added set_complexity to tools list

[acreeger]

iloom Session Summary

Key Themes:

• Workflow classification override: User reclassified issue from TRIVIAL to SIMPLE, demonstrating importance of human judgment over automated assessment
• Tool permission architecture: set_complexity required explicit allowlisting in multiple layers (ignite.ts, agent templates, orchestrator prompts)
• Orchestrator responsibility: Complexity tracking moved from just evaluator agent to orchestrators, ensuring complexity is captured at routing decision points

---

Session Details (click to expand)

Key Insights

• Multi-layer tool permission system: Adding a new MCP tool requires updates in 4 distinct places: (1) tool registration in recap-server.ts, (2) allowedTools arrays in ignite.ts for each workflow type, (3) tools frontmatter in agent templates, (4) Loom Recap documentation sections in orchestrator prompts
• Workflow routing decision points: Issue/PR orchestrators have explicit "ROUTING DECISION POINT" sections where complexity-based routing happens - this is where set_complexity should be called, not just during evaluation
• Complexity can change during workflow: User feedback revealed that complexity might be reclassified (e.g., evaluator says TRIVIAL but user overrides to SIMPLE), so orchestrators must call set_complexity with the confirmed classification, not just the initial assessment

Decisions Made

• Orchestrator prompts need set_complexity guidance: Initially planned to only update complexity-evaluator agent, but user correctly identified that issue-prompt, pr-prompt, and regular-prompt orchestrators must also call the tool when routing based on complexity or when users reclassify
• PR workflows get set_complexity despite simpler structure: Even though PR prompt doesn't have complex routing logic, it still gets access to set_complexity for consistency and potential future use
• Regular workflows include set_complexity: Non-issue/PR workflows (branch-based) also get the tool since complexity assessment could still be relevant for tracking session scope

Challenges Resolved

• Test assertion updates: Adding set_complexity to allowedTools arrays required updating 4 separate test assertions in ignite.test.ts - easy to miss one location and cause test failures
• Long tools line in agent frontmatter: The complexity-evaluator tools list was already lengthy; adding another tool required careful formatting to maintain readability (fixed spacing after comma)

Lessons Learned

• Always ask about orchestrator-level concerns: When adding workflow-related tools, explicitly consider whether orchestrators need to use them, not just specialized agents
• Tool permissions follow a pattern: baseTools array for issue/PR workflows, separate allowedTools for regular workflows, then test assertions mirror these structures exactly
• Implementation plans may need iteration: The analyze-and-plan agent produced a good initial plan, but user feedback improved it significantly by identifying the orchestrator prompt gap

---

Generated with 🤖❤️ by iloom.ai