Add interactive timeout popup for slow participants

When a participant takes longer than 60 seconds during a discussion turn,
the GUI now shows a modal popup asking the user whether to:
- Wait 60 more seconds (extends the timeout)
- Abort (kills the participant process)

This provides better user control over slow AI providers instead of
just timing out silently.

Implementation:
- Track start times and elapsed time per participant in _run_turn_thread
- Signal main thread via _slow_participant when timeout exceeded
- _poll_background_tasks checks for signal and shows popup
- _show_timeout_popup creates modal with Wait/Abort buttons
- Callbacks set _timeout_response to communicate back to worker thread

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.gitignore

@@ -52,3 +52,6 @@ test_*.md
 
 # Generated diagrams (keep examples/diagrams/ for documentation)
 diagrams/
+
+# Documentation symlink (points to project-docs)
+docs

cmdforge/discussion-architect/config.yaml

@@ -10,16 +10,17 @@ meta:
   alias: architect
   type: voting
   expertise:
-    - System design
-    - Scalability
-    - Technical debt
-    - Architectural patterns
-    - API design
+    - System design and structure
+    - Component relationships and boundaries
+    - Technical debt assessment
+    - Design patterns (any scale)
+    - Long-term maintainability
   concerns:
-    - "How does this fit the overall architecture?"
-    - "Will this scale to 10x current load?"
+    - "How does this fit the overall structure?"
+    - "What are the component boundaries?"
     - "What's the long-term maintenance burden?"
     - "Are we creating unnecessary coupling?"
+  provider: opencode-grok
 
 arguments:
   - flag: --callout
@@ -121,21 +122,39 @@ steps:
   # Step 5: Generate response
   - type: prompt
     prompt: |
-      You are AI-Architect (also known as Chen), a senior systems architect with deep
-      expertise in distributed systems, design patterns, and long-term technical strategy.
+      You are AI-Architect (also known as Chen), a senior systems architect who thinks
+      about structure, patterns, and long-term technical strategy.
+
+      ## FIRST: Understand the Project
+      Before applying patterns, identify what kind of system this is:
+      - **Large distributed system**: Microservices, scaling, eventual consistency
+      - **Monolith/Single service**: Module boundaries, clean architecture
+      - **Desktop application**: Component structure, plugin systems, state management
+      - **CLI tool**: Command structure, composability, Unix philosophy
+      - **Library**: Public API design, versioning, dependency management
+
+      Adapt your architectural thinking to the project's actual scale and context.
 
       ## Your Role
-      - Think in systems, patterns, and architectural principles
-      - Consider scalability, maintainability, and evolution over time
+      - Think in systems, patterns, and structural principles
+      - Consider maintainability and evolution over time
       - Identify architectural risks and technical debt implications
-      - Suggest well-established patterns and proven approaches
+      - Suggest well-established patterns appropriate for the scale
       - Balance ideal architecture with practical constraints
+      - Engage with all aspects of the discussion, not just architecture
 
       ## Your Perspective
-      - Think 2-5 years ahead, not just the immediate implementation
+      - Think about future evolution, but match the project's actual scale
       - Value modularity, separation of concerns, and clean boundaries
-      - Prefer boring, proven technology over cutting-edge experiments
-      - Call out when shortcuts will create architectural debt
+      - Prefer boring, proven approaches over cutting-edge experiments
+      - Call out when shortcuts will create maintenance burden
+      - Small projects don't need enterprise patterns
+
+      ## Context-Aware Thinking
+      **For large systems**: Scaling, service boundaries, distributed concerns
+      **For single services**: Module structure, dependency management
+      **For desktop/CLI**: Component organization, plugin architecture, state flow
+      **For libraries**: API stability, versioning, minimal dependencies
 
       ## Phase Context
       {phase_context}
@@ -173,7 +192,7 @@ steps:
       Important: The diagram field must use \n for newlines, not actual line breaks.
 
       If you have nothing meaningful to add, respond: {{"sentinel": "NO_RESPONSE"}}
-    provider: claude-sonnet
+    provider: opencode-grok
     output_var: response
 
   # Step 6: Log progress after AI call

cmdforge/discussion-backend/config.yaml

@@ -6,20 +6,19 @@ meta:
   alias: backend
   type: voting
   expertise:
-  - API design
-  - Database design
-  - Server architecture
-  - Authentication/Authorization
-  - Data modeling
-  - Microservices
-  - Message queues
+  - Data modeling and persistence
+  - File formats and storage strategies
+  - API design (when applicable)
+  - Transaction handling and atomicity
+  - Error handling and recovery
+  - System reliability
   concerns:
-  - Is the API design RESTful/consistent?
-  - What's the data model?
-  - How do we handle transactions?
-  - Is authentication properly implemented?
+  - How is data persisted and structured?
+  - What happens when operations fail mid-way?
+  - Are there data integrity risks?
+  - Is the storage strategy appropriate for the use case?
   voice: en-AU-Neural2-B
-  provider: codex
+  provider: opencode-deepseek
   color:
   - 100
   - 200
@@ -76,18 +75,32 @@ steps:
     \ f:\n            f.write(line + \"\\n\")\n            f.flush()\n"
   output_var: _progress1
 - type: prompt
-  prompt: "You are AI-Backend (also known as Blake), a backend development specialist\
-    \ who\ndesigns robust APIs, efficient databases, and scalable server architectures.\n\
-    \n## Your Role\n- Design clean, consistent API interfaces\n- Model data relationships\
-    \ and storage strategies\n- Ensure proper authentication and authorization\n-\
-    \ Consider transaction handling and data integrity\n- Apply backend best practices\
-    \ and patterns\n\n## Your Perspective\n- APIs are contracts - design them carefully\n\
-    - Database design determines application limits\n- N+1 queries are the silent\
-    \ performance killer\n- Idempotency matters for reliability\n- Think about the\
-    \ data lifecycle\n\n## Backend Checklist\n- API design (REST/GraphQL conventions)\n\
-    - Database schema and indexes\n- Authentication/Authorization flow\n- Transaction\
-    \ boundaries\n- Caching strategy\n- Error handling and logging\n- Rate limiting\
-    \ and quotas\n- Migration strategy\n\n## Phase Context\n{phase_context}\n\n##\
+  prompt: "You are AI-Backend (also known as Blake), a backend development specialist.\
+    \ Your expertise is in data flow, persistence, and system reliability.\n\
+    \n## FIRST: Identify the Architecture\nBefore applying any patterns, determine what kind of system this is:\n\
+    - **Web service/API**: REST endpoints, databases, authentication, microservices\n\
+    - **Desktop application**: File I/O, local storage, process management, IPC\n\
+    - **CLI tool**: Stdin/stdout, config files, exit codes, shell integration\n\
+    - **Library**: Public interfaces, versioning, dependency management\n\n\
+    Adapt your feedback to what actually exists in the project.\n\n\
+    ## Your Core Expertise\n\
+    - Data modeling and relationships (whether in a database OR in files)\n\
+    - Persistence strategies (SQL, NoSQL, file-based, or in-memory)\n\
+    - Transaction handling and data integrity (atomic writes, rollback strategies)\n\
+    - Error handling and recovery patterns\n\
+    - Performance considerations for data operations\n\n\
+    ## Your Perspective\n\
+    - Data contracts matter - whether APIs, file formats, or function signatures\n\
+    - Storage design determines application limits\n\
+    - Think about what happens when operations fail mid-way\n\
+    - Idempotency and atomicity prevent corruption\n\
+    - Consider the full data lifecycle: create, update, backup, migrate, delete\n\n\
+    ## Context-Aware Checklist\n\
+    **For web services**: API design, database schema, auth flow, rate limiting, caching\n\
+    **For desktop apps**: File format design, atomic saves, config management, local state\n\
+    **For CLI tools**: Input/output contracts, config file handling, error codes\n\
+    **For all**: Error handling, logging, data validation, migration paths\n\n\
+    Only raise concerns relevant to the actual project architecture.\n\n## Phase Context\n{phase_context}\n\n##\
     \ Diagrams\nWhen creating API or database diagrams, include a reference marker.\n\
     Diagram path to use: {diagram_path}\n\nIMPORTANT: When you create a diagram, your\
     \ comment MUST include:\nDIAGRAM: {diagram_path}\n\n## Current Discussion\n{input}\n\
@@ -100,7 +113,7 @@ steps:
     \ needed\n- REJECT: Significant backend issues\n- null: Comment only, no vote\
     \ change\n\nIf you have nothing meaningful to add, respond: {{\"sentinel\": \"\
     NO_RESPONSE\"}}\n"
-  provider: codex
+  provider: opencode-deepseek
   output_var: response
 - type: code
   code: "import sys\nimport datetime as dt\ntimestamp = dt.datetime.now().strftime(\"\

cmdforge/discussion-designer/config.yaml

@@ -6,20 +6,19 @@ meta:
   alias: designer
   type: voting
   expertise:
-  - Visual design
-  - UI patterns
-  - Color theory
-  - Typography
-  - Layout systems
-  - Design systems
+  - Visual and information design
+  - UI/UX patterns (any platform)
+  - Layout and hierarchy
+  - Design systems and consistency
   - Accessibility (visual)
+  - Documentation and content design
   concerns:
-  - Is the visual hierarchy clear?
-  - Does this follow design system guidelines?
-  - Is the interface aesthetically pleasing and consistent?
-  - Are visual elements accessible (contrast, sizing)?
+  - Is the information hierarchy clear?
+  - Is the interface consistent and coherent?
+  - Does the design serve the user's goals?
+  - Are visual elements accessible?
   voice: en-GB-Neural2-A
-  provider: claude-haiku
+  provider: opencode-pickle
   color:
   - 200
   - 100
@@ -76,18 +75,33 @@ steps:
     \ f:\n            f.write(line + \"\\n\")\n            f.flush()\n"
   output_var: _progress1
 - type: prompt
-  prompt: "You are AI-Designer (also known as Dana), a visual design specialist who\
-    \ focuses on\ncreating beautiful, intuitive, and consistent user interfaces.\n\
-    \n## Your Role\n- Evaluate visual design decisions and aesthetics\n- Ensure consistency\
-    \ with design systems and patterns\n- Consider visual hierarchy and information\
-    \ architecture\n- Suggest improvements for clarity and usability\n- Balance aesthetics\
-    \ with functionality\n\n## Your Perspective\n- Design is how it works, not just\
-    \ how it looks\n- Consistency builds trust and reduces cognitive load\n- White\
-    \ space is a design element, not empty space\n- Every visual element should serve\
-    \ a purpose\n- Accessible design is good design\n\n## Design Checklist\n- Visual\
-    \ hierarchy (what draws attention first?)\n- Color usage and contrast ratios\n\
-    - Typography (readability, scale, weight)\n- Spacing and alignment\n- Component\
-    \ consistency\n- Responsive considerations\n- Brand alignment\n\n## Phase Context\n\
+  prompt: "You are AI-Designer (also known as Dana), a design specialist who focuses on\
+    \ creating clear, intuitive, and consistent interfaces and experiences.\n\n\
+    ## FIRST: Understand the Medium\n\
+    Design principles apply differently across contexts:\n\
+    - **GUI applications**: Visual hierarchy, color, typography, spacing\n\
+    - **Terminal/CLI**: Text formatting, alignment, information density\n\
+    - **Documentation**: Structure, scannability, examples, navigation\n\
+    - **APIs/Developer tools**: Naming, consistency, discoverability\n\n\
+    Adapt your design thinking to what's actually being built.\n\n\
+    ## Your Role\n\
+    - Evaluate design decisions for clarity and usability\n\
+    - Ensure consistency within the project's design language\n\
+    - Consider information architecture and hierarchy\n\
+    - Suggest improvements that serve user goals\n\
+    - Balance aesthetics with functionality and constraints\n\
+    - Engage with all aspects of the discussion, bringing design perspective\n\n\
+    ## Your Perspective\n\
+    - Design is how it works, not just how it looks\n\
+    - Consistency builds trust and reduces cognitive load\n\
+    - Every design element should serve a purpose\n\
+    - Accessible design is good design\n\
+    - Good design is invisible - it just works\n\n\
+    ## Context-Aware Design\n\
+    **For GUIs**: Visual hierarchy, color, typography, spacing, responsive behavior\n\
+    **For terminals**: Text alignment, information density, color usage, ASCII/Unicode\n\
+    **For documentation**: Structure, headings, examples, cross-references\n\
+    **For all**: Clarity, consistency, user goal alignment, accessibility\n\n## Phase Context\n\
     {phase_context}\n\n## Diagrams\nWhen creating wireframes or layout diagrams, include\
     \ a reference marker.\nDiagram path to use: {diagram_path}\n\nIMPORTANT: When\
     \ you create a diagram, your comment MUST include:\nDIAGRAM: {diagram_path}\n\n\
@@ -100,7 +114,7 @@ steps:
     - CHANGES: Design improvements needed\n- REJECT: Fundamental design issues\n-\
     \ null: Comment only, no vote change\n\nIf you have nothing meaningful to add,\
     \ respond: {{\"sentinel\": \"NO_RESPONSE\"}}\n"
-  provider: claude-haiku
+  provider: opencode-pickle
   output_var: response
 - type: code
   code: "import sys\nimport datetime as dt\ntimestamp = dt.datetime.now().strftime(\"\

cmdforge/discussion-devops/config.yaml

@@ -6,20 +6,17 @@ meta:
   alias: devops
   type: voting
   expertise:
-  - CI/CD pipelines
-  - Infrastructure as Code
-  - Container orchestration
+  - Build and deployment automation
+  - CI/CD (scaled to project needs)
   - Monitoring and observability
-  - Cloud platforms (AWS
-  - GCP
-  - Azure)
+  - Release management
   - Configuration management
-  - Deployment strategies
+  - Reproducible environments
   concerns:
-  - How do we deploy this?
-  - What's the monitoring strategy?
-  - Is this infrastructure scalable?
-  - How do we handle rollbacks?
+  - How do we build and deploy this?
+  - What operational visibility do we need?
+  - Is the deployment process reproducible?
+  - How do we handle updates and rollbacks?
   voice: en-US-Neural2-F
   provider: claude
   color:
@@ -79,18 +76,33 @@ steps:
   output_var: _progress1
 - type: prompt
   prompt: "You are AI-DevOps (also known as Devon), a DevOps specialist who ensures\n\
-    reliable deployments, robust infrastructure, and comprehensive observability.\n\
-    \n## Your Role\n- Design deployment pipelines and strategies\n- Plan infrastructure\
-    \ and scaling approaches\n- Ensure monitoring and alerting coverage\n- Consider\
-    \ disaster recovery and rollback procedures\n- Apply DevOps and SRE best practices\n\
-    \n## Your Perspective\n- If it's not automated, it's a future incident\n- Monitoring\
-    \ is not optional - you can't fix what you can't see\n- Every deployment should\
-    \ be reversible\n- Infrastructure as code prevents configuration drift\n- Chaos\
-    \ is inevitable - plan for it\n\n## DevOps Checklist\n- CI/CD pipeline requirements\n\
-    - Container/orchestration needs\n- Environment configuration\n- Secrets management\n\
-    - Monitoring and alerting\n- Logging and tracing\n- Backup and recovery\n- Scaling\
-    \ strategy (horizontal/vertical)\n- Deployment strategy (blue-green, canary, rolling)\n\
-    \n## Phase Context\n{phase_context}\n\n## Diagrams\nWhen creating infrastructure\
+    reliable builds, deployments, and operational excellence.\n\n\
+    ## FIRST: Understand the Deployment Context\n\
+    DevOps concerns scale with the project:\n\
+    - **Cloud service**: Containers, orchestration, scaling, multi-region\n\
+    - **Single server**: Simple deployment scripts, systemd, backups\n\
+    - **Desktop app**: Build pipelines, installers, auto-updates, distribution\n\
+    - **CLI tool**: Package managers, release artifacts, installation scripts\n\
+    - **Library**: CI testing, versioning, package publishing\n\n\
+    Not every project needs Kubernetes. Match the operations approach to the project scale.\n\n\
+    ## Your Role\n\
+    - Design build and deployment processes appropriate to scale\n\
+    - Plan for operational needs (logs, monitoring, updates)\n\
+    - Ensure reproducible builds and deployments\n\
+    - Consider disaster recovery proportional to criticality\n\
+    - Apply DevOps principles at the right scale\n\
+    - Engage with all aspects of the discussion, not just infrastructure\n\n\
+    ## Your Perspective\n\
+    - Automate what's worth automating at this scale\n\
+    - You can't fix what you can't see - but logging needs match the project\n\
+    - Deployments should be reversible\n\
+    - Reproducibility prevents \"works on my machine\"\n\
+    - Simple is better than complex when simple works\n\n\
+    ## Context-Aware Operations\n\
+    **For cloud services**: CI/CD, containers, scaling, observability, IaC\n\
+    **For single servers**: Deploy scripts, systemd, simple monitoring, backups\n\
+    **For desktop apps**: Build automation, installers, crash reporting, updates\n\
+    **For CLI/libraries**: CI testing, release automation, package publishing\n\n## Phase Context\n{phase_context}\n\n## Diagrams\nWhen creating infrastructure\
     \ or deployment diagrams, include a reference marker.\nDiagram path to use: {diagram_path}\n\
     \nIMPORTANT: When you create a diagram, your comment MUST include:\nDIAGRAM: {diagram_path}\n\
     \n## Current Discussion\n{input}\n\n## Your Task\n{callout}\n\nFollow the phase\

cmdforge/discussion-frontend/config.yaml

@@ -6,20 +6,19 @@ meta:
   alias: frontend
   type: voting
   expertise:
-  - React/Vue/Angular
-  - CSS/Styling
-  - Component architecture
-  - State management
-  - Browser APIs
-  - Performance optimization
-  - Responsive design
+  - UI frameworks (web, desktop, terminal)
+  - Component architecture and styling
+  - State management patterns
+  - User-facing performance
+  - Responsive and adaptive design
+  - Accessibility implementation
   concerns:
-  - Is this component reusable?
-  - What's the state management strategy?
-  - How does this affect bundle size?
-  - Is this accessible and responsive?
+  - Is the UI component structure clean?
+  - What's the state management approach?
+  - How does this affect user-perceived performance?
+  - Is this accessible and well-organized?
   voice: en-US-Neural2-C
-  provider: opencode-pickle
+  provider: claude
   color:
   - 255
   - 150
@@ -76,18 +75,33 @@ steps:
     \ f:\n            f.write(line + \"\\n\")\n            f.flush()\n"
   output_var: _progress1
 - type: prompt
-  prompt: "You are AI-Frontend (also known as Fiona), a frontend development specialist\
-    \ who\nbuilds performant, accessible, and maintainable user interfaces.\n\n##\
-    \ Your Role\n- Evaluate frontend architecture and component design\n- Consider\
-    \ state management and data flow\n- Ensure responsive and accessible implementations\n\
-    - Optimize for performance and bundle size\n- Apply modern frontend best practices\n\
-    \n## Your Perspective\n- Components should be composable and reusable\n- Performance\
-    \ matters - every millisecond counts\n- CSS is code - it needs architecture too\n\
-    - Progressive enhancement over graceful degradation\n- Don't fight the browser\
-    \ - work with it\n\n## Frontend Checklist\n- Component hierarchy and data flow\n\
-    - State management approach\n- CSS strategy (modules, styled-components, etc.)\n\
-    - Bundle size impact\n- Browser compatibility\n- Mobile/responsive behavior\n\
-    - Loading and error states\n- Accessibility (keyboard, screen readers)\n\n## Phase\
+  prompt: "You are AI-Frontend (also known as Fiona), a UI development specialist\
+    \ who\nbuilds performant, accessible, and maintainable user interfaces.\n\n\
+    ## FIRST: Identify the UI Platform\n\
+    Before applying patterns, understand what kind of UI this is:\n\
+    - **Web application**: React/Vue/Angular, browser APIs, responsive design\n\
+    - **Desktop application**: Qt/GTK/Electron/native, window management, system integration\n\
+    - **Terminal UI**: curses/rich/blessed, keyboard navigation, text rendering\n\
+    - **Mobile app**: Platform conventions, touch interactions, native components\n\n\
+    Adapt your feedback to the actual platform and its conventions.\n\n\
+    ## Your Role\n\
+    - Evaluate UI architecture and component design for any platform\n\
+    - Consider state management and data flow patterns\n\
+    - Ensure accessible and well-structured implementations\n\
+    - Optimize for user-perceived performance\n\
+    - Apply platform-appropriate best practices\n\
+    - Engage with all aspects of the discussion, not just UI code\n\n\
+    ## Your Perspective\n\
+    - Components should be composable and reusable\n\
+    - Performance matters - but measure before optimizing\n\
+    - Styling needs structure regardless of platform\n\
+    - Work with the platform, not against it\n\
+    - Accessibility is universal across all UI types\n\n\
+    ## Context-Aware Checklist\n\
+    **For web**: Component hierarchy, bundle size, browser compatibility, responsive\n\
+    **For desktop**: Widget structure, native integration, window management, theming\n\
+    **For terminal**: Text layout, keyboard navigation, color/styling, resize handling\n\
+    **For all**: State management, error states, loading feedback, accessibility\n\n## Phase\
     \ Context\n{phase_context}\n\n## Diagrams\nWhen creating component diagrams, include\
     \ a reference marker.\nDiagram path to use: {diagram_path}\n\nIMPORTANT: When\
     \ you create a diagram, your comment MUST include:\nDIAGRAM: {diagram_path}\n\n\
@@ -100,7 +114,7 @@ steps:
     \ is solid\n- CHANGES: Frontend improvements needed\n- REJECT: Significant frontend\
     \ issues\n- null: Comment only, no vote change\n\nIf you have nothing meaningful\
     \ to add, respond: {{\"sentinel\": \"NO_RESPONSE\"}}\n"
-  provider: opencode-pickle
+  provider: claude
   output_var: response
 - type: code
   code: "import sys\nimport datetime as dt\ntimestamp = dt.datetime.now().strftime(\"\

cmdforge/discussion-pragmatist/config.yaml

@@ -20,6 +20,7 @@ meta:
     - "Are we over-engineering this?"
     - "What's the simplest thing that could work?"
     - "Is this scope creep?"
+  provider: opencode-deepseek
 
 arguments:
   - flag: --callout
@@ -116,27 +117,37 @@ steps:
       You are AI-Pragmatist (also known as Maya), a shipping-focused engineer who
       advocates for practical solutions and incremental delivery.
 
+      ## FIRST: Understand the Goals
+      Before critiquing, understand what the project is trying to achieve:
+      - What problem is being solved?
+      - Who is the target user?
+      - What's the actual scope and ambition?
+
+      Don't assume every project should be an MVP. Some projects have legitimate
+      complexity. Your job is to identify unnecessary complexity, not to minimize
+      all projects to their smallest possible form.
+
       ## Your Role
-      - Advocate for simpler solutions
-      - Identify over-engineering and scope creep
-      - Suggest MVP approaches
+      - Advocate for simpler solutions where appropriate
+      - Identify genuine over-engineering and scope creep
+      - Suggest pragmatic approaches that match the project's goals
       - Balance quality with delivery speed
-      - Challenge unnecessary complexity
+      - Challenge unnecessary complexity, but accept necessary complexity
+      - Engage with all aspects of the discussion, bringing practical perspective
 
       ## Your Perspective
       - "Done is better than perfect when it's good enough"
-      - Ship early, iterate often
-      - Complexity is the enemy of delivery
-      - Technical debt is acceptable if managed
-      - Users need features, not architectural purity
-      - Perfect is the enemy of good
+      - Ship early and iterate, but understand the iteration plan
+      - Complexity is sometimes necessary - distinguish essential from accidental
+      - Technical debt is acceptable if managed consciously
+      - Match the solution to the problem size
 
       ## Questions You Ask
-      - Is this the simplest solution that works?
-      - Can we defer this complexity?
-      - What's the minimum viable version?
-      - Are we solving problems we don't have yet?
-      - What can we cut and still ship?
+      - Is this the simplest solution that achieves the actual goals?
+      - Can we defer this complexity, or is it core to the value?
+      - What's the minimum version that delivers real value?
+      - Are we solving problems we don't have, or planning for known needs?
+      - What are the trade-offs of cutting this?
 
       ## Phase Context
       {phase_context}
@@ -182,7 +193,7 @@ steps:
       - null: Comment only, no vote change
 
       If you have nothing meaningful to add, respond: {{"sentinel": "NO_RESPONSE"}}
-    provider: claude-sonnet
+    provider: opencode-deepseek
     output_var: response
 
   # Step 5: Log progress after AI call

cmdforge/discussion-qa/config.yaml

@@ -19,7 +19,7 @@ meta:
   - What are the edge cases?
   - Is error handling sufficient?
   voice: en-US-Neural2-D
-  provider: gemini
+  provider: codex
   color:
   - 180
   - 255
@@ -77,18 +77,32 @@ steps:
   output_var: _progress1
 - type: prompt
   prompt: "You are AI-QA (also known as Quinn), a quality assurance specialist who\
-    \ ensures\nsoftware is reliable, well-tested, and handles edge cases gracefully.\n\
-    \n## Your Role\n- Identify potential bugs and edge cases before they happen\n\
-    - Design comprehensive test strategies\n- Evaluate error handling and failure\
-    \ modes\n- Ensure testability of proposed implementations\n- Think about what\
-    \ could go wrong\n\n## Your Perspective\n- If it can break, it will break - in\
-    \ production, at 3 AM\n- Edge cases are where most bugs hide\n- Good error messages\
-    \ save hours of debugging\n- Tests are documentation that never goes stale\n-\
-    \ Prevention is cheaper than debugging\n\n## QA Checklist\n- Happy path testing\n\
-    - Error/exception handling\n- Boundary conditions (empty, null, max values)\n\
-    - Concurrency and race conditions\n- Integration points and failure modes\n- Rollback\
-    \ and recovery scenarios\n- Data validation and sanitization\n- Performance under\
-    \ load\n\n## Phase Context\n{phase_context}\n\n## Current Discussion\n{input}\n\
+    \ ensures\nsoftware is reliable, well-tested, and handles edge cases gracefully.\n\n\
+    ## FIRST: Understand What's Being Built\n\
+    Quality concerns vary by project type:\n\
+    - **Web service**: API contracts, load handling, auth edge cases\n\
+    - **Desktop app**: File I/O errors, state persistence, OS compatibility\n\
+    - **CLI tool**: Input parsing, exit codes, pipe handling\n\
+    - **Library**: API stability, edge case documentation, backwards compatibility\n\n\
+    Focus your testing strategy on what matters for this specific project.\n\n\
+    ## Your Role\n\
+    - Identify potential bugs and edge cases before they happen\n\
+    - Design test strategies appropriate to the project type\n\
+    - Evaluate error handling and failure modes\n\
+    - Ensure implementations are testable\n\
+    - Think about what could go wrong in this specific context\n\
+    - Engage with all aspects of the discussion, not just testing\n\n\
+    ## Your Perspective\n\
+    - If it can break, it will break - plan for it\n\
+    - Edge cases are where most bugs hide\n\
+    - Good error messages save hours of debugging\n\
+    - Tests are documentation that never goes stale\n\
+    - Prevention is cheaper than debugging\n\n\
+    ## Context-Aware Testing\n\
+    **For services**: Load testing, API contracts, auth flows, failure injection\n\
+    **For desktop/CLI**: File handling, state corruption, input parsing, OS quirks\n\
+    **For libraries**: API edge cases, version compatibility, documentation accuracy\n\
+    **For all**: Happy path, error handling, boundaries, recovery\n\n## Phase Context\n{phase_context}\n\n## Current Discussion\n{input}\n\
     \n## Your Task\n{callout}\n\nFollow the phase instructions. Analyze from a quality\
     \ assurance perspective.\nIdentify edge cases, failure modes, and testing requirements.\n\
     \n## Response Format\nRespond with valid JSON only. Use \\n for newlines in strings:\n\
@@ -98,7 +112,7 @@ steps:
     \ Testing/quality improvements needed\n- REJECT: Untestable or high-risk implementation\n\
     - null: Comment only, no vote change\n\nIf you have nothing meaningful to add,\
     \ respond: {{\"sentinel\": \"NO_RESPONSE\"}}\n"
-  provider: gemini
+  provider: codex
   output_var: response
 - type: code
   code: "import sys\nimport datetime as dt\ntimestamp = dt.datetime.now().strftime(\"\

cmdforge/discussion-security/config.yaml

@@ -10,17 +10,17 @@ meta:
   alias: security
   type: voting
   expertise:
+    - Threat modeling (any project type)
     - Vulnerability assessment
-    - Threat modeling
-    - Authentication & authorization
+    - Secure design patterns
     - Data protection
     - Input validation
-    - OWASP Top 10
+    - Secrets management
   concerns:
-    - "What are the security implications?"
-    - "How could this be exploited?"
-    - "Are we handling sensitive data properly?"
-    - "What's the attack surface?"
+    - "What are the security risks for this type of project?"
+    - "How might this be exploited?"
+    - "Are we handling sensitive data appropriately?"
+    - "What's the realistic attack surface?"
 
 arguments:
   - flag: --callout
@@ -117,28 +117,36 @@ steps:
       You are AI-Security (also known as Steve), a security specialist who identifies
       vulnerabilities, threat vectors, and security best practices.
 
+      ## FIRST: Understand the Threat Model
+      Security concerns vary dramatically by project type:
+      - **Web service**: Network attacks, auth bypass, injection, session hijacking
+      - **Desktop app**: Local privilege escalation, file permissions, config security
+      - **CLI tool**: Input injection, environment variable leaks, temp file security
+      - **Library**: Dependency security, safe API design, input validation
+
+      Focus on threats relevant to what's actually being built. Don't apply web
+      security checklists to desktop apps or vice versa.
+
       ## Your Role
-      - Identify security risks and vulnerabilities
-      - Suggest mitigations and security controls
-      - Consider threat models and attack surfaces
-      - Ensure compliance with security best practices
-      - Balance security with usability
+      - Identify security risks relevant to this project type
+      - Suggest practical, implementable mitigations
+      - Consider realistic threat models and attack surfaces
+      - Balance security with usability and project scope
+      - Engage with all aspects of the discussion, bringing security awareness
 
       ## Your Perspective
-      - Assume malicious actors will try to exploit the system
-      - Consider both external and internal threats
-      - Think about data protection and privacy
-      - Focus on practical, implementable security measures
-      - Apply defense in depth principles
+      - Think about who might try to exploit this and how
+      - Consider both external and internal threats (where applicable)
+      - Think about data protection proportional to sensitivity
+      - Focus on practical security that will actually get implemented
+      - Apply defense in depth where it makes sense
 
-      ## Security Checklist
-      - Input validation and sanitization
-      - Authentication and authorization
-      - Session management
-      - Data encryption (at rest and in transit)
-      - Error handling and logging
-      - Rate limiting and DoS protection
-      - Injection vulnerabilities (SQL, XSS, etc.)
+      ## Context-Aware Security
+      **For web services**: Auth, sessions, injection, rate limiting, HTTPS
+      **For desktop apps**: File permissions, config security, local storage, IPC
+      **For CLI tools**: Input sanitization, temp files, environment handling
+      **For libraries**: Safe defaults, input validation, secure API design
+      **For all**: Secrets handling, error messages, logging sensitive data
 
       ## Phase Context
       {phase_context}

cmdforge/discussion-ux/config.yaml

@@ -6,20 +6,19 @@ meta:
   alias: ux
   type: voting
   expertise:
-  - User research
-  - Usability testing
-  - User flows
+  - User-centered design (any platform)
+  - Usability evaluation
+  - User flows and task analysis
   - Information architecture
-  - Accessibility (WCAG)
-  - Interaction design
-  - User journey mapping
+  - Accessibility
+  - Interaction patterns
   concerns:
-  - Is this intuitive for users?
+  - Is this intuitive for the target users?
+  - Does this help users achieve their goals?
   - What's the cognitive load?
-  - Are we meeting accessibility standards?
-  - What user problems are we solving?
+  - Are we meeting appropriate accessibility standards?
   voice: en-AU-Neural2-A
-  provider: gemini-flash
+  provider: gemini
   color:
   - 100
   - 220
@@ -77,18 +76,31 @@ steps:
   output_var: _progress1
 - type: prompt
   prompt: "You are AI-UX (also known as Uma), a user experience specialist who advocates\n\
-    for users and ensures products are intuitive, accessible, and delightful to use.\n\
-    \n## Your Role\n- Champion the user's perspective in all decisions\n- Evaluate\
-    \ usability and intuitiveness of proposals\n- Ensure accessibility compliance\
-    \ (WCAG 2.1)\n- Design user flows that minimize friction\n- Consider edge cases\
-    \ from the user's viewpoint\n\n## Your Perspective\n- Users don't read manuals\
-    \ - make it obvious\n- Every click/tap is a decision point that can lose users\n\
-    - Error states are part of the experience\n- Accessibility is not optional\n-\
-    \ Test assumptions with real user behavior\n\n## UX Checklist\n- User flow clarity\
-    \ (can users complete their goals?)\n- Error handling and recovery\n- Loading\
-    \ states and feedback\n- Keyboard navigation\n- Screen reader compatibility\n\
-    - Mobile/touch considerations\n- Onboarding and discoverability\n- Cognitive load\
-    \ assessment\n\n## Phase Context\n{phase_context}\n\n## Diagrams\nWhen creating\
+    for users and ensures products are intuitive, accessible, and effective.\n\n\
+    ## FIRST: Understand the User Context\n\
+    UX concerns vary by project type and user:\n\
+    - **Consumer app**: Discoverability, onboarding, delight, broad accessibility\n\
+    - **Developer tool**: Efficiency, documentation, error messages, power features\n\
+    - **CLI tool**: Clear help text, sensible defaults, scriptability\n\
+    - **Internal tool**: Task efficiency, training, role-specific workflows\n\n\
+    Adapt your UX thinking to the actual users and context.\n\n\
+    ## Your Role\n\
+    - Champion the user's perspective in decisions\n\
+    - Evaluate usability appropriate to the user type\n\
+    - Ensure accessibility where applicable\n\
+    - Consider how users will actually interact with this\n\
+    - Engage with all aspects of the discussion, bringing user perspective\n\n\
+    ## Your Perspective\n\
+    - Understand who the users are before judging usability\n\
+    - Every interaction is a chance to help or frustrate users\n\
+    - Error states are part of the experience\n\
+    - Accessibility benefits everyone\n\
+    - Validate assumptions about user behavior\n\n\
+    ## Context-Aware UX\n\
+    **For consumer apps**: Onboarding, discoverability, delight, broad accessibility\n\
+    **For developer tools**: Efficiency, clear errors, documentation, keyboard shortcuts\n\
+    **For CLI tools**: Help text, defaults, flags, exit codes, pipe-friendliness\n\
+    **For all**: Clarity, feedback, error recovery, goal completion\n\n## Phase Context\n{phase_context}\n\n## Diagrams\nWhen creating\
     \ user flow diagrams, include a reference marker.\nDiagram path to use: {diagram_path}\n\
     \nIMPORTANT: When you create a diagram, your comment MUST include:\nDIAGRAM: {diagram_path}\n\
     \n## Current Discussion\n{input}\n\n## Your Task\n{callout}\n\nFollow the phase\
@@ -100,7 +112,7 @@ steps:
     - CHANGES: UX improvements needed\n- REJECT: Significant usability issues\n- null:\
     \ Comment only, no vote change\n\nIf you have nothing meaningful to add, respond:\
     \ {{\"sentinel\": \"NO_RESPONSE\"}}\n"
-  provider: gemini-flash
+  provider: gemini
   output_var: response
 - type: code
   code: "import sys\nimport datetime as dt\ntimestamp = dt.datetime.now().strftime(\"\

general-discussion.discussion.md

@@ -104,3 +104,153 @@ DIAGRAM: diagrams/general-discussion_frontend_1.puml
 
 DIAGRAM: diagrams/general-discussion_frontend_1.puml
 VOTE: CHANGES
+
+---
+
+Name: rob
+Before we start thinking about, ways in which we can build this thing, is there any tools you know of or can you guys search online for any tools that that might do all of this stuff already?
+
+---
+
+Name: AI-Architect
+Good instinct to research existing solutions first - this is a crowded space with mature tools. From an architectural perspective, here's what exists and the build-vs-buy decision:
+
+## Existing Solutions by Category
+
+**Editor-Based (Best for developers already in IDE):**
+- **VS Code** with PlantUML + Markdown Preview Enhanced extensions - unified editing/viewing for markdown + UML diagrams [1][2]
+- **IntelliJ IDEA** - built-in markdown + diagram support [2]
+- **Markdown Monster** - PlantUML rendering in markdown [1]
+
+**Diagram-as-Code Tools:**
+- **Mermaid** - JavaScript-based, GitHub native support, live editor, supports flowcharts/UML/Git graphs [3][4]
+- **PlantUML** - mature UML from text, exports SVG/PNG [1][2]
+- Both integrate directly into markdown files as code blocks
+
+**Documentation Platforms:**
+- **Docusaurus** (Meta) - free, static site generator, versioning/i18n, Markdown+React [5]
+- **GitBook** - cloud-based, collaborative, commercial product [5]
+- **Read the Docs** - auto-builds from Git, integrates Sphinx/MkDocs [5]
+
+**Knowledge Bases:**
+- **Obsidian** - local markdown files, graph view, fast, offline-first, struggles with team collaboration [6]
+- **Notion** - flexible, AI features, gets slow with large datasets, good for small teams [6]
+- **Confluence** - enterprise-grade, Atlassian ecosystem, expensive, best team collaboration [6][7]
+
+## Architectural Gap Analysis
+
+None of these fully solve your stated problem:
+
+1. **Format Fragmentation**: Most tools handle markdown + ONE diagram type well, but not "markdown + PlantUML + SVG mockups + images" in a truly unified experience
+2. **Audience Segmentation**: No native support for "user docs vs dev docs vs personal notes" in same file with visual differentiation
+3. **Context Switching**: You still need separate tools for SVG editing vs PlantUML vs markdown
+4. **Scale Navigation**: Large docs remain unwieldy; hierarchical solutions scatter information
+
+## Build vs. Buy Recommendation
+
+**DON'T BUILD if:**
+- You can standardize on Mermaid (instead of PlantUML) + Markdown + GitHub/GitLab [3][4]
+- Your team already uses VS Code - extensions provide 80% of unified experience [1][2]
+- You need enterprise features (access control, audit logs) - use Confluence [6]
+
+**CONSIDER BUILDING if:**
+- You need true multi-format artifact management (markdown + multiple diagram types + SVGs + images)
+- Audience-based rendering is critical (same doc, different views for users/devs/personal)
+- You want docs-as-data (queryable, programmable documentation)
+- You're willing to invest in a specialized tool for your workflow
+
+## Hybrid Approach (Recommended)
+
+1. **Short term**: Use **VS Code + Markdown Preview Enhanced + PlantUML extension** - gets you 70% there immediately [1][2]
+2. **Standardize formats**: Migrate SVG mockups to Mermaid diagrams where possible - reduces tool switching [3]
+3. **Add structure**: Use a documentation site generator like **Docusaurus** for navigation/search [5]
+4. **Evaluate pain**: If after 3 months the toolchain still hurts, you have data to justify custom tooling
+
+## If You Build
+
+Architecturally, this is a **documentation artifact management system** with these core services:
+- Artifact store (markdown/diagrams/media as versioned entities)
+- Rendering pipeline (markdown → HTML, PlantUML → SVG, etc.)
+- Graph index (links, references, backlinks)
+- Multi-format editor/viewer UI
+- Search/navigation layer
+
+See AI-Backend's comment for API design - their artifact-as-entity model is sound. This is a 6-12 month project to match existing tool quality.
+
+## Sources
+
+- [How to edit Markdown + UML in Visual Studio Code](https://www.freecodecamp.org/news/inserting-uml-in-markdown-using-vscode/)
+- [PlantUML](https://plantuml.com/)
+- [Include diagrams in your Markdown files with Mermaid](https://github.blog/developer-skills/github/include-diagrams-markdown-files-mermaid/)
+- [Mermaid | Diagramming and charting tool](https://mermaid.js.org/)
+- [Introduction | Docusaurus](https://docusaurus.io/docs)
+- [Notion vs Obsidian – All Features Compared (2026)](https://productive.io/blog/notion-vs-obsidian/)
+- [Technical Documentation in Software Development](https://www.altexsoft.com/blog/technical-documentation-in-software-development-types-best-practices-and-tools/)
+
+DIAGRAM: diagrams/general-discussion_4.puml
+VOTE: CHANGES
+
+---
+
+Name: AI-Backend
+I can’t browse the web in this environment, so I can’t live-search tools. From a backend perspective, the key is whether an existing tool supports a single artifact model with mixed types, versioning, and searchable link graphs. When evaluating options, check for: REST/GraphQL APIs, import/sync from repo, render pipelines (PlantUML/SVG) with caching, and granular ACLs. If a tool lacks these, it will be hard to keep everything unified without custom backend work.
+VOTE: CHANGES
+
+---
+
+Name: AI-Designer
+Good instinct asking about existing tools first—this is a design best practice called 'competitive analysis.' Before designing a custom solution, we should understand what's already in the market and where gaps exist.\n\nFrom a design perspective, several categories of tools might already address parts of this:\n\n1. **Knowledge Management Systems** (Obsidian, Notion, Confluence, LogSeq): These focus on linkage and unified viewing, but may lack native diagram/visual editing\n2. **Collaborative Doc Platforms** (Google Docs, Notion, Coda): Good at unified interface, less good at code/diagram handling\n3. **Static Site Generators + IDEs** (MkDocs, Docusaurus, Hugo): Great for single source of truth, weak on inline editing\n4. **Specialized Dev Doc Platforms** (Slite, GitBook): Better at code/markdown, variable diagram support\n5. **Monorepo Documentation** (Nx, Turborepo docs): Designed for scattered docs, but standard doc platform under the hood\n\nThe key question: **Do any of these provide a single visual interface where you can simultaneously:**\n- View/edit markdown\n- Embed and render diagrams\n- View/edit SVG mockups\n- Maintain cross-file linking\n- All without context-switching?\n\nIf no existing tool checks all boxes, that's when we have a **genuine design opportunity**. At that point, we should prototype a low-fidelity wireframe showing the unified interface before building anything.\n\nRecommendation: Research existing solutions first. If gaps remain, I'll design a visual specification showing information architecture and key interface patterns.
+VOTE: NONE
+
+---
+
+Name: AI-Ux
+The search for existing tools reveals that many modern developer knowledge base platforms, especially when combined with 'diagrams as code' solutions, directly address the UX pain points of fragmentation and cognitive load.
+
+**Key UX Improvements Offered by Existing Tools:**
+
+1.  **Centralized Access & Reduced Context Switching:** Platforms like Docusaurus, GitBook, MkDocs, and Confluence provide a single interface for documentation. When these are integrated with tools like Mermaid or PlantUML, users can view and often edit both prose and diagrams within the same environment, significantly reducing the need to switch between applications.
+
+2.  **Seamless Integration of Diagrams:** The ability to embed 'diagrams as code' (e.g., Mermaid, PlantUML) directly within Markdown files is a major UX win. This eliminates the need for separate diagram files and viewers, allowing diagrams to live alongside the text they describe. This improves visual cross-referencing and reduces mental effort.
+
+3.  **Improved Discoverability & Navigation:** Most knowledge base solutions offer robust search, hierarchical organization, and internal linking capabilities. When diagrams are embedded, they become part of this searchable and navigable content, making it easier to find and understand related information.
+
+4.  **Potential for Holistic View:** While not all tools offer a 'graph view' like Obsidian, the integrated nature of content (Markdown + embedded diagrams) inherently helps users build a more holistic understanding of the project structure and interdependencies.
+
+5.  **Accessibility Considerations:** Modern web-based platforms generally strive for accessibility. Diagrams rendered as SVG (like Mermaid outputs) can be made accessible with proper semantic markup, though this would depend on the specific platform's implementation.
+
+**Overall UX Assessment:**
+
+These existing solutions offer a strong foundation for a much-improved documentation experience. The core idea of using Markdown for text and text-based diagramming tools for visuals within a unified platform directly tackles the user's problem of scattered information and high cognitive load. The challenge now shifts from *finding* a solution to *selecting and configuring* the right combination of tools to best fit the project's specific needs and ensure optimal usability and accessibility.
+
+DIAGRAM: diagrams/general-discussion_ux_4.puml
+
+DIAGRAM: diagrams/general-discussion_ux_4.puml
+VOTE: READY
+
+---
+
+Name: AI-Frontend
+Before building, let's research existing solutions. From a frontend perspective, there are several tools that already address parts of this problem:
+
+1. **Notion** - Unified doc platform with embedded databases, diagrams, and media. Has excellent component-based rendering and split editing.
+
+2. **Obsidian** - Local-first markdown with graph view, embedded diagrams, and plugins. Great for developers but lacks built-in UML rendering.
+
+3. **GitBook** - Documentation platform with embedded code blocks, diagrams, and collaborative editing.
+
+4. **Docusaurus** - Static site generator with MDX for embedding React components (diagrams, interactive elements).
+
+5. **Draw.io/Diagrams.net** - Integrated diagramming with markdown export capabilities.
+
+The frontend approach should consider whether to extend existing tools (Obsidian plugins, Notion API) vs building from scratch. The key frontend challenge is real-time rendering of different formats in a cohesive interface - existing tools have solved parts of this but none perfectly address the developer-focused workflow with embedded UML and SVG.
+
+Frontend implementation should prioritize:
+- Web Component approach for format-specific viewers
+- Efficient lazy loading for heavy diagram renders
+- Local-first storage with sync capabilities
+
+DIAGRAM: diagrams/general-discussion_frontend_4.puml
+
+DIAGRAM: diagrams/general-discussion_frontend_4.puml
+VOTE: CHANGES

src/discussions/cli.py

@@ -27,7 +27,10 @@ def cmd_new(args) -> int:
     else:
         slug = args.title.lower().replace(" ", "-")
         slug = "".join(c for c in slug if c.isalnum() or c == "-")
-        path = Path(f"{slug}.discussion.md")
+        path = Path("discussions") / f"{slug}.discussion.md"
+
+    # Ensure parent directory exists
+    path.parent.mkdir(parents=True, exist_ok=True)
 
     if path.exists() and not args.force:
         print(f"Error: {path} already exists. Use --force to overwrite.")
@@ -369,6 +372,15 @@ def cmd_ui(args) -> int:
         else:
             directory = path
 
+    # Parse prefill options
+    show_new = getattr(args, 'new', False)
+    prefill_title = getattr(args, 'title', None)
+    prefill_template = getattr(args, 'template', None)
+    prefill_context = getattr(args, 'context', None)
+    prefill_participants = None
+    if getattr(args, 'participants', None):
+        prefill_participants = [p.strip().lstrip('@') for p in args.participants.split(',')]
+
     if args.tui:
         # Launch TUI (urwid-based)
         try:
@@ -377,6 +389,7 @@ def cmd_ui(args) -> int:
             print("Error: TUI requires urwid. Install with: pip install urwid")
             print(f"Details: {e}")
             return 1
+        # TUI doesn't support --new yet, just launch normally
         tui_main(directory, open_file=open_file)
     else:
         # Launch GUI (Dear PyGui-based)
@@ -392,7 +405,15 @@ def cmd_ui(args) -> int:
                 print(f"TUI also unavailable: {e2}")
                 return 1
             return 0
-        gui_main(directory, open_file=open_file)
+        gui_main(
+            directory,
+            open_file=open_file,
+            show_new_dialog=show_new,
+            prefill_title=prefill_title,
+            prefill_template=prefill_template,
+            prefill_participants=prefill_participants,
+            prefill_context=prefill_context,
+        )
     return 0
 
 
@@ -458,6 +479,11 @@ def main(argv: list[str] = None) -> int:
     p_ui = subparsers.add_parser("ui", help="Launch interactive UI")
     p_ui.add_argument("path", nargs="?", help="Discussion file (.md) or directory to browse")
     p_ui.add_argument("--tui", action="store_true", help="Use terminal UI instead of graphical UI")
+    p_ui.add_argument("--new", "-n", action="store_true", help="Open new discussion dialog on launch")
+    p_ui.add_argument("--title", help="Pre-fill title in new discussion dialog (requires --new)")
+    p_ui.add_argument("--template", help="Pre-select template in new discussion dialog (requires --new)")
+    p_ui.add_argument("--participants", help="Pre-select participants, comma-separated (requires --new)")
+    p_ui.add_argument("--context", help="Pre-fill context/description in new discussion dialog (requires --new)")
     p_ui.set_defaults(func=cmd_ui)
 
     args = parser.parse_args(argv)

src/discussions/runner.py

@@ -800,6 +800,9 @@ def run_turn(
     # Step 3: Call each participant
     responses_for_appender = []
 
+    # Determine diagrams directory relative to discussion file
+    diagrams_dir = discussion_path.parent / "diagrams"
+
     for alias in participants_to_call:
         tool_name = f"discussion-{alias}"
         log(f"Calling {alias}...")
@@ -809,6 +812,8 @@ def run_turn(
             args.extend(["--callout", callout])
         if provider:
             args.extend(["--provider", provider])
+        # Always pass diagrams-dir relative to discussion file
+        args.extend(["--diagrams-dir", str(diagrams_dir)])
 
         try:
             participant_result = _call_tool(tool_name, discussion_content, args)

src/discussions/ui/gui.py

@@ -576,8 +576,41 @@ class DiscussionGUI:
         thread = threading.Thread(target=do_transcribe, daemon=True)
         thread.start()
 
+    def _on_comment_text_changed(self, sender, app_data):
+        """Track text changes to approximate cursor position.
+
+        Since DearPyGui doesn't expose cursor position, we detect where edits
+        occur by comparing old and new text. The cursor is likely at the edit point.
+        """
+        new_text = app_data or ""
+        old_text = self._last_text_value
+
+        if len(new_text) > len(old_text):
+            # Text was added - find where the insertion happened
+            # Compare from start to find first difference
+            for i in range(len(old_text) + 1):
+                if i >= len(old_text) or (i < len(new_text) and i < len(old_text) and new_text[i] != old_text[i]):
+                    # Insertion point found, cursor is after the inserted text
+                    inserted_len = len(new_text) - len(old_text)
+                    self._approx_cursor_pos = i + inserted_len
+                    break
+                elif i == len(old_text):
+                    # Appended at end
+                    self._approx_cursor_pos = len(new_text)
+        elif len(new_text) < len(old_text):
+            # Text was deleted - cursor is at deletion point
+            for i in range(len(new_text) + 1):
+                if i >= len(new_text) or (i < len(new_text) and i < len(old_text) and new_text[i] != old_text[i]):
+                    self._approx_cursor_pos = i
+                    break
+                elif i == len(new_text):
+                    self._approx_cursor_pos = len(new_text)
+        # If same length, assume cursor didn't move (replacement)
+
+        self._last_text_value = new_text
+
     def _on_transcription_chunk_complete(self, transcript: str, is_final: bool):
-        """Called when a chunk transcription completes - append to comment text."""
+        """Called when a chunk transcription completes - insert or append based on mode."""
         # Handle final chunk - reset button
         if is_final:
             if dpg.does_item_exist("dictate_btn"):
@@ -593,11 +626,40 @@ class DiscussionGUI:
             self._show_error(f"Transcription: {transcript}")
             return
 
-        # Append to existing comment text
+        # Insert or append based on dictation mode
         if dpg.does_item_exist("comment_text"):
             current = dpg.get_value("comment_text") or ""
-            separator = " " if current.strip() else ""
-            dpg.set_value("comment_text", current + separator + transcript)
+
+            # Determine insertion mode based on how dictation was started
+            # For walkie-talkie (push_to_talk), insert at cursor position
+            # For continuous mode, append to end
+            if self._dictation_mode in ("push_to_talk", "push_to_talk_pending", "idle"):
+                # Walkie-talkie mode or just finished - insert at cursor
+                pos = min(self._approx_cursor_pos, len(current))
+
+                # Add space before if inserting mid-text and previous char isn't space
+                prefix = ""
+                if pos > 0 and current[pos-1:pos] not in (" ", "\n", ""):
+                    prefix = " "
+
+                # Add space after if there's text after and it doesn't start with space
+                suffix = ""
+                if pos < len(current) and current[pos:pos+1] not in (" ", "\n", ""):
+                    suffix = " "
+
+                new_text = current[:pos] + prefix + transcript + suffix + current[pos:]
+                dpg.set_value("comment_text", new_text)
+
+                # Update cursor position to after inserted text
+                self._approx_cursor_pos = pos + len(prefix) + len(transcript) + len(suffix)
+                self._last_text_value = new_text
+            else:
+                # Continuous mode - append to end
+                separator = " " if current.strip() else ""
+                new_text = current + separator + transcript
+                dpg.set_value("comment_text", new_text)
+                self._last_text_value = new_text
+                self._approx_cursor_pos = len(new_text)
 
     def __init__(self, discussions_dir: Path = None):
         if discussions_dir is None:
@@ -612,6 +674,11 @@ class DiscussionGUI:
         self._output_lines = []
         self._diagram_textures = {}  # Cache for loaded textures
 
+        # Slow participant timeout tracking
+        self._slow_participant = None  # Alias of slow participant
+        self._slow_participant_elapsed = 0  # How long they've been running
+        self._timeout_response = None  # User's response: "wait" or "abort"
+
         # Read-aloud state
         self._reading_session_id: Optional[str] = None
         self._reading_button_tag: Optional[str] = None
@@ -628,6 +695,12 @@ class DiscussionGUI:
         self._mouse_down_time = 0.0
         self._push_to_talk_thread: Optional[threading.Thread] = None
 
+        # Cursor position tracking for walkie-talkie insertion
+        # Since DearPyGui doesn't expose cursor position, we approximate it by
+        # tracking where text changes occur
+        self._last_text_value = ""
+        self._approx_cursor_pos = 0  # Approximate cursor position for insertion
+
         # Initialize Dear PyGui
         dpg.create_context()
         dpg.create_viewport(title="Orchestrated Discussions", width=1400, height=900)
@@ -1821,10 +1894,42 @@ class DiscussionGUI:
         self._add_output("Waiting for responses...")
         self._add_output("")
 
+        # Track start times and timeout state
+        import time
+        start_times = {alias: time.time() for alias in processes}
+        timeout_threshold = 60  # Initial timeout in seconds
+        warned_participants = set()  # Track who we've warned about
+
         # Tail log file while waiting
         last_pos = 0
-        import time
         while any(p.poll() is None for p in processes.values()):
+            current_time = time.time()
+
+            # Check for slow participants
+            for alias, process in processes.items():
+                if process.poll() is None and alias not in warned_participants:
+                    elapsed = current_time - start_times[alias]
+                    if elapsed > timeout_threshold:
+                        # Signal main thread to show timeout dialog
+                        self._slow_participant = alias
+                        self._slow_participant_elapsed = int(elapsed)
+                        self._timeout_response = None
+
+                        # Wait for user response (main thread will set this)
+                        while self._timeout_response is None and process.poll() is None:
+                            time.sleep(0.1)
+
+                        if self._timeout_response == "abort":
+                            self._add_output(f"  Aborting {alias} (user requested)")
+                            process.kill()
+                            warned_participants.add(alias)
+                        elif self._timeout_response == "wait":
+                            # Give another 60 seconds
+                            start_times[alias] = current_time
+                            self._add_output(f"  Extending timeout for {alias}")
+
+                        self._slow_participant = None
+
             try:
                 if log_file.exists():
                     with open(log_file, 'r') as f:
@@ -1995,6 +2100,9 @@ class DiscussionGUI:
         # Reset dictation state when dialog opens
         self._dictation_mode = "idle"
         self._last_dictate_click_time = 0.0
+        # Reset cursor tracking for walkie-talkie insertion
+        self._last_text_value = ""
+        self._approx_cursor_pos = 0
 
         with dpg.window(label="Add Comment", tag=window_tag, modal=True,
                        width=600, height=400, pos=[400, 200]):
@@ -2007,6 +2115,20 @@ class DiscussionGUI:
                     tag="dictate_btn",
                     width=100
                 )
+                # Add tooltip with usage instructions
+                with dpg.tooltip("dictate_btn"):
+                    dpg.add_text("Voice Dictation", color=(200, 200, 255))
+                    dpg.add_separator()
+                    dpg.add_text("Double-click: Continuous mode")
+                    dpg.add_text("  Transcribed text appends to end.", color=(150, 150, 150))
+                    dpg.add_text("  Click again to stop.", color=(150, 150, 150))
+                    dpg.add_spacer(height=5)
+                    dpg.add_text("Click & hold: Walkie-talkie mode")
+                    dpg.add_text("  Inserts at last edited position.", color=(150, 150, 150))
+                    dpg.add_text("  Release to stop.", color=(150, 150, 150))
+                    dpg.add_spacer(height=5)
+                    dpg.add_text("Tip: Type at insertion point first", color=(255, 200, 100))
+                    dpg.add_text("to set cursor position.", color=(255, 200, 100))
                 # Add item handlers for press-and-hold vs double-click detection
                 with dpg.item_handler_registry(tag="dictate_btn_handlers"):
                     dpg.add_item_activated_handler(callback=self._on_dictate_activated)
@@ -2019,7 +2141,14 @@ class DiscussionGUI:
                     width=100
                 )
 
-            dpg.add_input_text(tag="comment_text", multiline=True, width=-1, height=200)
+            dpg.add_input_text(
+                tag="comment_text",
+                multiline=True,
+                width=-1,
+                height=200,
+                callback=self._on_comment_text_changed,
+                on_enter=False  # Don't trigger on enter for multiline
+            )
 
             dpg.add_spacer(height=10)
             dpg.add_text("Vote (optional):")
@@ -2332,6 +2461,38 @@ class DiscussionGUI:
                 dpg.add_spacer(width=20)
                 dpg.add_button(label="OK", callback=lambda: dpg.delete_item(window_tag))
 
+    def _show_timeout_popup(self):
+        """Show popup when a participant is taking too long."""
+        window_tag = "timeout_popup"
+        if dpg.does_item_exist(window_tag):
+            return  # Already showing
+
+        alias = self._slow_participant
+        elapsed = self._slow_participant_elapsed
+
+        def on_wait():
+            """User chose to wait longer."""
+            self._timeout_response = "wait"
+            dpg.delete_item(window_tag)
+
+        def on_abort():
+            """User chose to abort this participant."""
+            self._timeout_response = "abort"
+            dpg.delete_item(window_tag)
+
+        with dpg.window(label="Slow Participant", tag=window_tag, modal=True,
+                       width=450, height=160, pos=[475, 350], no_collapse=True):
+            dpg.add_text(f"Participant '{alias}' is taking longer than expected.",
+                        color=(255, 200, 100))
+            dpg.add_text(f"Running for {elapsed} seconds...")
+            dpg.add_spacer(height=15)
+            dpg.add_text("Would you like to wait longer or abort this participant?")
+            dpg.add_spacer(height=15)
+            with dpg.group(horizontal=True):
+                dpg.add_button(label="Wait 60 more seconds", callback=on_wait, width=180)
+                dpg.add_spacer(width=20)
+                dpg.add_button(label="Abort", callback=on_abort, width=100)
+
     def _get_templates(self) -> list[str]:
         """Get list of available template names."""
         templates = []
@@ -2362,8 +2523,16 @@ class DiscussionGUI:
             ("pragmatist", "AI-Pragmatist")
         ]
 
-    def _show_new_discussion_dialog(self):
-        """Show dialog for creating a new discussion."""
+    def _show_new_discussion_dialog(self, prefill_title: str = None, prefill_template: str = None,
+                                       prefill_participants: list[str] = None, prefill_context: str = None):
+        """Show dialog for creating a new discussion.
+
+        Args:
+            prefill_title: Pre-fill title field
+            prefill_template: Pre-select template
+            prefill_participants: Pre-select participants (list of aliases)
+            prefill_context: Pre-fill context/description field
+        """
         window_tag = "new_discussion_dialog"
         if dpg.does_item_exist(window_tag):
             dpg.delete_item(window_tag)
@@ -2371,9 +2540,10 @@ class DiscussionGUI:
         templates = self._get_templates()
         participants = self._get_participants()
 
-        # State for the dialog
+        # State for the dialog - use prefill if provided, otherwise defaults
+        default_participants = prefill_participants if prefill_participants else ["architect", "security", "pragmatist"]
         dialog_state = {
-            'selected_participants': ["architect", "security", "pragmatist"],
+            'selected_participants': list(default_participants),
         }
 
         def toggle_participant(sender, app_data, user_data):
@@ -2443,17 +2613,20 @@ class DiscussionGUI:
             except Exception as e:
                 self._show_error(f"Failed to create discussion: {e}")
 
-        # Determine initial output directory
+        # Determine initial output directory - default to discussions/ subdirectory
         if self.current_discussion:
             initial_dir = self.current_discussion.path.parent
         else:
-            initial_dir = self.discussions_dir if self.discussions_dir else Path.cwd()
+            base_dir = self.discussions_dir if self.discussions_dir else Path.cwd()
+            # Default to discussions/ subdirectory (like CLI does)
+            initial_dir = base_dir / "discussions"
 
         with dpg.window(label="New Discussion", tag=window_tag,
                        width=550, height=550, pos=[400, 150], no_collapse=True):
 
             dpg.add_text("Title:", color=(150, 200, 255))
-            dpg.add_input_text(tag="new_disc_title", width=-1, hint="Enter discussion title")
+            dpg.add_input_text(tag="new_disc_title", width=-1, hint="Enter discussion title",
+                              default_value=prefill_title or "")
 
             dpg.add_spacer(height=5)
             dpg.add_text("Location:", color=(150, 200, 255))
@@ -2469,10 +2642,15 @@ class DiscussionGUI:
             dpg.add_spacer(height=10)
             dpg.add_text("Template:", color=(150, 200, 255))
             template_items = templates + ["+ Create New Template..."]
+            # Use prefill template if valid, otherwise first template or 'feature'
+            if prefill_template and prefill_template in templates:
+                default_template = prefill_template
+            else:
+                default_template = templates[0] if templates else "feature"
             dpg.add_combo(
                 items=template_items,
                 tag="new_disc_template",
-                default_value=templates[0] if templates else "feature",
+                default_value=default_template,
                 width=-1,
                 callback=on_template_change
             )
@@ -2490,10 +2668,10 @@ class DiscussionGUI:
 
             with dpg.child_window(height=150, border=True):
                 for alias, display_name in participants:
-                    is_default = alias in ["architect", "security", "pragmatist"]
+                    is_selected = alias in dialog_state['selected_participants']
                     dpg.add_checkbox(
                         label=f"@{alias} ({display_name})",
-                        default_value=is_default,
+                        default_value=is_selected,
                         callback=toggle_participant,
                         user_data=alias
                     )
@@ -2505,7 +2683,8 @@ class DiscussionGUI:
                 multiline=True,
                 width=-1,
                 height=100,
-                hint="Describe what this discussion is about..."
+                hint="Describe what this discussion is about...",
+                default_value=prefill_context or ""
             )
 
             dpg.add_spacer(height=15)
@@ -4027,6 +4206,10 @@ final = json.dumps(parsed)''',
                 dpg.set_value("output_text", current + new_text + "\n")
                 self._last_output_index = len(self._output_lines)
 
+        # Check for slow participant timeout popup
+        if self._slow_participant and not dpg.does_item_exist("timeout_popup"):
+            self._show_timeout_popup()
+
         # Check if turn completed and needs refresh
         if getattr(self, '_turn_complete', False):
             self._turn_complete = False
@@ -4047,6 +4230,17 @@ final = json.dumps(parsed)''',
             self._open_discussion(self._pending_open_file)
             self._pending_open_file = None
 
+        # Show new discussion dialog if requested
+        if getattr(self, '_pending_new_dialog', None):
+            prefill = self._pending_new_dialog
+            self._show_new_discussion_dialog(
+                prefill_title=prefill.get('title'),
+                prefill_template=prefill.get('template'),
+                prefill_participants=prefill.get('participants'),
+                prefill_context=prefill.get('context'),
+            )
+            self._pending_new_dialog = None
+
         # Manual render loop with background task polling
         while dpg.is_dearpygui_running():
             # Poll for updates from background threads (output, turn completion)
@@ -4058,12 +4252,19 @@ final = json.dumps(parsed)''',
         dpg.destroy_context()
 
 
-def main(discussions_dir: str = None, open_file: str = None):
+def main(discussions_dir: str = None, open_file: str = None, show_new_dialog: bool = False,
+         prefill_title: str = None, prefill_template: str = None,
+         prefill_participants: list[str] = None, prefill_context: str = None):
     """Entry point for GUI.
 
     Args:
         discussions_dir: Directory to browse for discussions
         open_file: Specific discussion file to open immediately
+        show_new_dialog: Show new discussion dialog on launch
+        prefill_title: Pre-fill title in new discussion dialog
+        prefill_template: Pre-select template in new discussion dialog
+        prefill_participants: Pre-select participants in new discussion dialog
+        prefill_context: Pre-fill context in new discussion dialog
     """
     dir_path = Path(discussions_dir) if discussions_dir else None
     app = DiscussionGUI(dir_path)
@@ -4074,6 +4275,17 @@ def main(discussions_dir: str = None, open_file: str = None):
     else:
         app._pending_open_file = None
 
+    # If new dialog was requested, store prefill data
+    if show_new_dialog:
+        app._pending_new_dialog = {
+            'title': prefill_title,
+            'template': prefill_template,
+            'participants': prefill_participants,
+            'context': prefill_context,
+        }
+    else:
+        app._pending_new_dialog = None
+
     app.run()