diff --git a/docs/plans/2026-02-04-feature-ideas-brainstorm.md b/docs/plans/2026-02-04-feature-ideas-brainstorm.md new file mode 100644 index 00000000..da541661 --- /dev/null +++ b/docs/plans/2026-02-04-feature-ideas-brainstorm.md @@ -0,0 +1,432 @@ +# ResolutionFlow Feature Ideas Brainstorm + +> **Date:** February 4, 2026 +> **Participants:** Michael Chihlas, Claude +> **Context:** Brainstorming features tailored to MSP engineers, focused on the "document as you go" gap + +--- + +## Design Principle + +Every feature should follow the core principle that makes ResolutionFlow work: +**Engineers don't document — they troubleshoot, and the tool captures documentation as a byproduct.** + +New features should: +- Reduce engineer cognitive load +- Automate capture of what they're already doing +- Make reusing knowledge frictionless +- Reduce context switching during troubleshooting + +--- + +## Ideas Summary + +| # | Feature | Category | Effort | Priority Signal | +|---|---------|----------|--------|-----------------| +| 1 | Session Time Tracking | Export enhancement | Small | High — quick win | +| 2 | Share Progress / Escalation | Collaboration | Medium | High — daily use | +| 3 | Command Output Capture | Context capture | Small | High — quick win | +| 4 | Push Steps to Active Sessions | Collaboration | Medium-Large | Medium — needs notification system | +| 5 | Path Analytics | Intelligence | Medium | Medium — needs session volume | +| 6 | Session Scratchpad | Context capture | Small-Medium | High — must-have (per Michael) | +| 7 | Multi-Tree Sessions | Session enhancement | Large | Medium — complex UX | +| 8 | Recurring Issue Detection | Intelligence | Small-Medium | High — leverages existing data | +| 9 | Tree Health Scores | Intelligence | Medium | Medium — needs session volume | +| 10 | AI Tree Intelligence | Intelligence | Large | Long-term — ultimate vision | + +--- + +## Idea 1: Session Time Tracking + +**Category:** Export enhancement +**Effort:** Small (backend export change, no new UI) + +### What +Every session automatically tracks duration (start → end) and includes it in the export. + +### Export Output +``` +Session Duration: 23 minutes +Started: 2:30 PM | Completed: 2:53 PM +``` + +### Why +MSP engineers bill by the hour. They troubleshoot in ResolutionFlow, export notes, then separately log time in their PSA. This eliminates the second step. + +### Implementation Notes +- Timestamps already exist in session decisions — just compute elapsed time +- Add duration to export templates (markdown, text, HTML) +- No new UI required — purely a backend export enhancement + +### Future Enhancement +- When PSA integration exists: if no PSA connected, ResolutionFlow tracks time natively. If PSA connected, still track time but also push it directly to the ticket in the PSA. +- Analytics: average resolution time per tree, per client, per engineer + +--- + +## Idea 2: Share Progress / Escalation + +**Category:** Collaboration +**Effort:** Medium + +### What +Two mechanisms for sharing in-progress troubleshooting context: + +1. **"Share Progress" button** (available mid-session) — generates a formatted summary of steps completed so far. Copy to clipboard, paste into Teams/Slack. One click instead of typing "here's what I've tried." + +2. **Read-only session link** — shareable URL where anyone with the link can see the session state. If they sign in and get assigned, they can resume from where the previous engineer left off. + +### Workflow +1. Junior engineer gets stuck → clicks "Share Progress" +2. Pastes formatted summary into Teams chat with senior +3. Senior reads structured summary (not a wall of chat text) +4. If needed, senior opens the read-only link to see full detail +5. If escalating: ticket reassigned in PSA, senior resumes the session in ResolutionFlow + +### Implementation Notes +- Copy/paste version is nearly free — existing export logic on incomplete sessions + "Steps remaining" section +- Read-only link: generate share token, create public read-only session view (no auth) +- Resume capability: allow session reassignment to another user + +### Why This Matters +Eliminates the "what have you tried so far?" back-and-forth that happens on every escalation. The structured format means the senior gets context in 30 seconds instead of 10 minutes of chat. + +--- + +## Idea 3: Command Output Capture + +**Category:** Context capture +**Effort:** Small + +### What +Action nodes (which show commands to run) get an optional "Paste Output" text area. Engineer runs the command, copies output, pastes it in. + +### Export Output +``` +> Ran: Get-Service -Name Spooler +> Output: +> Status: Stopped +> Name: Spooler +> Decision: Service was stopped, proceeded to restart +``` + +### Why +Engineers already run commands and read output. Today the output is lost — the export says "ran this command" but not what it returned. This captures the evidence. + +### Implementation Notes +- Add optional `command_output` field to session decision JSONB +- Add collapsible text area below commands on action nodes in TreeNavigationPage +- Include in export with code formatting +- Pairs well with Scratchpad (Idea 6) and Share Progress (Idea 2) + +### Future Enhancement +- Syntax highlighting for common output formats (PowerShell, JSON) +- Image paste for screenshots of GUI-based evidence + +--- + +## Idea 4: Push Steps to Active Sessions + +**Category:** Collaboration +**Effort:** Medium-Large + +### What +A senior engineer (or anyone) can send a troubleshooting step directly to someone's active session. Flips the step library from a pull model (browse and find) to a push model (someone sends it to you). + +### Workflow +1. Junior shares progress link (Idea 2) +2. Senior sees they're stuck at "VDA not registering" +3. Senior picks a step from their personal library (or types one quickly) +4. Senior hits "Send to [Junior]" → step appears as notification in junior's session +5. Junior sees: "Michael sent you a step: Check Citrix Broker Service binding" +6. One click to insert into session +7. Step documented in export, optionally saved to junior's library + +### Why +Replaces unstructured Teams/Slack troubleshooting advice with structured, documented, reusable steps. The knowledge stays in the system. + +### Implementation Notes +- Requires lightweight notification/inbox system (polling or WebSocket) +- Builds on: Share Progress (Idea 2) + Step Library (existing) +- New API: `POST /api/v1/sessions/{id}/send-step` +- Frontend: notification badge + step insertion flow + +### Analytics Potential +- Which seniors send the most steps (mentorship tracking) +- Which pushed steps get reused (knowledge value) +- Which juniors receive fewer pushes over time (skill growth) + +--- + +## Idea 5: Path Analytics — "The Road Most Traveled" + +**Category:** Intelligence +**Effort:** Medium + +### What +Aggregate completed session data to show statistical hints on decision nodes: + +- Badge: "78% of engineers chose Option B here" +- On solution nodes: "Resolved the issue 92% of the time" +- At common stuck points: "Engineers often add a custom step here" + +### Why +Delivers on the tagline. For a junior engineer staring at three options, seeing "most engineers went this way" is a confidence boost. For tree authors, analytics reveal dead-end branches. + +### Implementation Notes +- Aggregate query on session `path_taken` and `decisions` JSONB +- Compute per-node: choice distribution, resolve rate, custom step frequency +- Cache aggregates (recompute daily or on-demand) +- Display as subtle badges on decision nodes (not intrusive) +- Resolve rate: track whether session completed at a solution node + optional "did this fix it?" prompt + +### Data Requirements +- Needs sufficient session volume per tree to be statistically meaningful (suggest: show after 10+ sessions) +- Weight recent sessions higher than old ones + +--- + +## Idea 6: Session Scratchpad + +**Category:** Context capture +**Effort:** Small-Medium +**Priority:** Must-have (per Michael) + +### What +A persistent sidebar during active sessions for capturing ambient data: IP addresses, error codes, server names, usernames — anything that doesn't fit a specific decision node's notes field. + +### Why +During troubleshooting, engineers accumulate bits of data (from `ipconfig`, Event Viewer, phone conversations) that live on sticky notes or in their head. This gives it a home and includes it in the export. + +### Export Output +``` +## Evidence / Reference +- Server IP: 192.168.1.50 +- Error code: 0x80070005 +- Affected user: jsmith@contoso.com +- Event ID: 4625 (repeated 47 times in last hour) +``` + +### Implementation Notes +- Persistent sidebar (collapsible) in TreeNavigationPage +- Store in session JSONB as `scratchpad` array of entries +- Each entry: text + optional label + timestamp +- Include in export as "Evidence / Reference" section +- Start simple: just a text area with "Add Note" button +- Future: structured key-value pairs, tags, image paste + +### Pairs With +- Command Output Capture (Idea 3): structured output at nodes + freeform notes in scratchpad = complete evidence +- Share Progress (Idea 2): scratchpad content included in shared summary + +--- + +## Idea 7: Multi-Tree Sessions + +**Category:** Session enhancement +**Effort:** Large + +### What +When troubleshooting reveals the problem is in a different domain, branch into another tree mid-session without losing context. The export captures the entire journey. + +### Workflow +1. Engineer is in "VPN Issues" tree, 5 steps deep +2. Discovers the actual problem is DNS, not VPN +3. Clicks "Open Related Tree" → selects "DNS Resolution Issues" +4. Current tree bookmarked, linked session starts in DNS tree +5. DNS session completes → returns to VPN tree where they left off +6. Export shows unified narrative with both trees + +### Export Output +``` +## VPN Connection Issues +1. Verified VPN client version: OK +2. Checked tunnel status: UP +3. Tested connectivity through tunnel: FAIL + → Branched to: DNS Resolution Issues + + ## DNS Resolution Issues (linked) + 1. Ran nslookup: timeout + 2. Checked DNS config: wrong DC + 3. Resolution: Updated DNS to 10.0.0.5 + +4. Returned to VPN - retested: PASS +5. Resolution: DNS misconfiguration causing apparent VPN failure +``` + +### Implementation Notes +- Session model needs: `parent_session_id`, `branched_at_node_id` +- "Open Related Tree" action on any node (tree selector modal) +- Breadcrumb shows tree chain: VPN > DNS +- Export renderer handles nested/linked sessions +- Back button returns to parent session at bookmark point + +### Why +Real troubleshooting rarely stays in one domain. This captures the full diagnostic story. + +--- + +## Idea 8: Recurring Issue Detection + +**Category:** Intelligence +**Effort:** Small-Medium + +### What +When an engineer starts a session and enters a client name, show previous sessions for that client in that tree. If the same resolution keeps being reached, prompt for root cause action. + +### UI +- At session start: "3 previous sessions for Warner Robins in this tree (last: Jan 28)" + link to view +- At resolution (if recurring): "This is the 3rd time this issue was resolved the same way for this client. Consider documenting a permanent fix or escalating to address root cause." + +### Why +Turns ResolutionFlow from reactive (fix the ticket) to proactive (fix the root cause). For MSP managers, recurring issues per client = business intelligence for infrastructure upgrade proposals. + +### Implementation Notes +- Query: sessions grouped by client_name + tree_id, count + last date +- Display at session start (inline, not blocking) +- Recurrence prompt: compare resolution node_id across sessions +- Future (with PSA/RMM): correlate with alert data for richer signals + +### Data Model +- No schema changes needed — query existing sessions table +- Optional: normalize client names (fuzzy match or client_id foreign key) + +--- + +## Idea 9: Tree Health Scores + +**Category:** Intelligence +**Effort:** Medium + +### What +Data-driven health indicators for trees, surfaced to tree authors and admins. + +### Signals +- **Custom step frequency**: Engineers keep adding steps at the same node → tree is missing a branch +- **Abandonment rate**: Sessions started but not completed → tree isn't leading to resolutions +- **Low resolve rate**: Solution nodes that don't actually fix issues +- **Staleness**: No updates in X months for a technology area that changes frequently +- **Escalation rate**: High percentage of sessions shared/escalated from this tree + +### Display +- Green/yellow/red health badge on tree library cards +- Author notification: "Your 'VPN Issues' tree has yellow health — 4 engineers added custom steps at 'Check Split Tunnel Config' this month" +- Admin dashboard: team-wide tree health overview + +### Why +Creates a self-improving ecosystem. Sessions generate data → data identifies weak trees → authors improve trees → next engineer gets a better experience. + +### Implementation Notes +- Scheduled aggregation job (daily) +- Health score algorithm: weighted combination of signals +- Store as computed field on tree (or separate analytics table) +- Notification system (pairs with Push Steps notification infrastructure, Idea 4) + +--- + +## Idea 10: AI Tree Intelligence (Long-term Vision) + +**Category:** Intelligence +**Effort:** Large (phased) +**Status:** Ultimate goal + +### What +Three layers of AI, each building on the last, leveraging ResolutionFlow's unique structured troubleshooting dataset. + +### Layer 1: Smart Tree Suggestions +- Engineer pastes ticket description: "User at Warner Robins reports Outlook keeps crashing after latest update" +- AI suggests: "Recommended: Outlook/Email Issues tree → Start at 'Recent Update' branch" +- Not just which tree — which branch to start at, skipping generic initial questions +- **Implementation:** NLP parsing of ticket text, match against tree node content and tags + +### Layer 2: Session-Driven Tree Evolution +- Aggregate session data reveals patterns: "35% of engineers add 'Check MFA Token' after 'Auth Failed' node, and it resolves 80% of the time" +- Generate suggestion to tree author: "Recommended new branch based on 18 successful sessions" +- Author reviews and approves with one click — tree evolves from real usage +- **Implementation:** Aggregation queries + LLM formatting suggestions + author approval UI + +### Layer 3: AI Tree Generation +- Senior describes: "We keep getting Azure AD Sync issues, no tree exists" +- AI generates complete tree draft using: + - Similar trees in the system + - Custom steps engineers have created for Azure AD + - Resolution patterns from session history + - Real PowerShell commands from command output captures +- Senior reviews, tweaks, publishes +- **Implementation:** RAG over tree corpus + session data + LLM generation + tree editor integration + +### Why This Is the Moat +ConnectWise or IT Glue could build a decision tree tool. But they don't have hundreds of structured session paths with outcomes to learn from. ResolutionFlow's data is structured by design — decision trees + session paths + outcomes — not unstructured ticket notes. That's a dataset purpose-built for learning optimal troubleshooting paths. + +### Phasing +- Layer 1 can ship independently with basic NLP +- Layer 2 needs sufficient session volume (6+ months of real usage) +- Layer 3 needs Layers 1 + 2 data + LLM integration + +--- + +## Quick Actions Dashboard (Bonus) + +**Category:** UX improvement +**Effort:** Medium + +### What +Replace the tree library as the default landing page with a troubleshooting command center. + +### Sections +- **Resume sessions** — "VPN Issues - Acme Corp (started 20 min ago)" for incomplete sessions +- **Quick starts** — Frequent tree+client combos: "File Share Access for Warner Robins — Quick start?" One tap. +- **Team activity** — "Sarah completed 'AD Replication' for Client X (12 min)" — visibility without a standup +- **Your trees** — Health scores for trees you authored, pending suggestions from AI (Layer 2) +- **Recurring alerts** — Clients with repeat issues that need attention + +### Why +Turns ResolutionFlow from a tool you visit per-ticket into something you keep open all day. Reduces friction from "open app → find tree → start session" to "open app → click the obvious next action." + +--- + +## Suggested Build Order + +### Near-term (build now, small effort, immediate value) +1. **Session Scratchpad** (Idea 6) — must-have per Michael +2. **Session Time Tracking** (Idea 1) — quick win, enhances every export +3. **Command Output Capture** (Idea 3) — quick win, pairs with scratchpad + +### Mid-term (build next, medium effort, high value) +4. **Share Progress / Escalation** (Idea 2) — daily use for team collaboration +5. **Recurring Issue Detection** (Idea 8) — leverages existing data immediately +6. **Quick Actions Dashboard** (Bonus) — improves daily UX +7. **Path Analytics** (Idea 5) — needs session volume, start collecting data now + +### Later (larger effort, needs foundation) +8. **Push Steps to Active Sessions** (Idea 4) — needs notification system +9. **Tree Health Scores** (Idea 9) — needs session volume + analytics infrastructure +10. **Multi-Tree Sessions** (Idea 7) — complex UX, large refactor + +### Long-term vision +11. **AI Tree Intelligence** (Idea 10) — phased rollout, ultimate differentiator + +--- + +## Dependencies & Connections + +``` +Scratchpad (6) ──────────────────────────────┐ +Command Output (3) ──────────────────────────┤ +Time Tracking (1) ───────────────────────────┤── Enhanced Exports + │ +Share Progress (2) ──┬── Push Steps (4) ─────┤── Collaboration + │ │ + └── Notification System ─┘ + +Path Analytics (5) ──┬── Tree Health (9) ────┬── AI Intelligence (10) +Recurring Issues (8) ┘ │ + │ +Multi-Tree Sessions (7) ────────────────────┘ +``` + +Key insight: Ideas 1, 3, and 6 (time tracking, command output, scratchpad) are independent quick wins that make exports richer. Ideas 2 and 4 (share progress, push steps) build a collaboration layer. Ideas 5, 8, 9, and 10 (analytics, recurring issues, health, AI) form the intelligence layer that grows with usage. + +--- + +*Generated during brainstorming session, February 4, 2026*