empathy-framework 4.5.1__py3-none-any.whl → 4.6.0__py3-none-any.whl

{empathy_framework-4.5.1.dist-info → empathy_framework-4.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: empathy-framework
-Version: 4.5.1
+Version: 4.6.0
 Summary: AI collaboration framework with real LLM agent execution, AskUserQuestion tool integration, Socratic agent generation, progressive tier escalation (70-85% cost savings), meta-orchestration, dynamic agent composition (6 patterns), intelligent caching (85% hit rate), semantic workflow discovery, visual workflow editor, MCP integration for Claude Code, and multi-agent orchestration.
 Author-email: Patrick Roebuck <admin@smartaimemory.com>
 Maintainer-email: Smart-AI-Memory <admin@smartaimemory.com>
@@ -359,7 +359,7 @@ Dynamic: license-file
 
 **The AI collaboration framework with breakthrough meta-orchestration - agents that compose themselves.**
 
-🎭 **v4.5: Production-Ready Agent Teams** - Real LLM execution, VS Code integration, rich reports.
+🎭 **v4.6: $0 Cost AI Workflows** - Run agent teams free with any Claude Code subscription, Socratic agent creation, memory-enhanced learning.
 
 [![PyPI](https://img.shields.io/pypi/v/empathy-framework)](https://pypi.org/project/empathy-framework/)
 [![Tests](https://img.shields.io/badge/tests-7%2C200%2B%20passing-brightgreen)](https://github.com/Smart-AI-Memory/empathy-framework/actions)
@@ -372,6 +372,49 @@ Dynamic: license-file
 pip install empathy-framework[developer]  # Lightweight for individual developers
 ```
 
+## What's New in v4.6.0 💰 **$0 COST AI WORKFLOWS**
+
+### **Run Agent Teams Free with Any Claude Code Subscription**
+
+**v4.6** revolutionizes how you use Empathy Framework - all multi-agent workflows now run **at no additional cost** when you have any Claude Code subscription.
+
+**Key Features:**
+
+- 💰 **$0 Execution** - Agent teams use Claude Code's Task tool instead of API calls
+- 🎓 **Socratic Agent Creation** - `/create-agent` and `/create-team` guide you through building custom agents
+- 🧠 **Memory Enhancement** - Optional short-term and long-term memory for agents that learn
+- 🧹 **Streamlined Skills** - 13 clean skills that work without API keys
+
+**Quick Start (Claude Code):**
+
+```
+/create-agent     # Walk through creating a custom AI agent
+/create-team      # Build a multi-agent team with guided questions
+/release-prep     # Run 4-agent release readiness check ($0)
+/test-coverage    # 3-agent coverage analysis ($0)
+```
+
+**Available Skills:**
+
+| Skill | Description | Cost |
+|-------|-------------|------|
+| `/create-agent` | Socratic guide to build custom agents | $0 |
+| `/create-team` | Build multi-agent teams interactively | $0 |
+| `/release-prep` | Security, coverage, quality, docs check | $0 |
+| `/test-coverage` | Coverage gap analysis + suggestions | $0 |
+| `/test-maintenance` | Find stale/flaky tests | $0 |
+| `/manage-docs` | Keep docs in sync with code | $0 |
+| `/feature-overview` | Generate technical documentation | $0 |
+
+**Enterprise API Mode** (optional):
+
+```bash
+# For CI/CD, cron jobs, or programmatic control
+empathy meta-workflow run release-prep --real --use-defaults
+```
+
+---
+
 ## What's New in v4.5.0 🖥️ **VS CODE INTEGRATION**
 
 ### **Rich HTML Reports for Agent Team Execution**
@@ -1469,7 +1512,7 @@ For those interested in the development history and architectural decisions:
 
 - **[Development Logs](https://github.com/Smart-AI-Memory/empathy-framework/tree/main/docs/development-logs/)** — Execution plans, phase completions, and progress tracking
 - **[Architecture Docs](https://github.com/Smart-AI-Memory/empathy-framework/tree/main/docs/architecture/)** — System design, memory architecture, and integration plans
-- **[Marketing Materials](https://github.com/Smart-AI-Memory/empathy-framework/tree/main/docs/marketing/)** — Pitch decks, outreach templates, and commercial readiness
+- **[Claude Code Skills](.claude/commands/)** — AI-powered workflows and custom agent creation
 - **[Guides](https://github.com/Smart-AI-Memory/empathy-framework/tree/main/docs/guides/)** — Publishing tutorials, MkDocs setup, and distribution policies
 
 ---

{empathy_framework-4.5.1.dist-info → empathy_framework-4.6.0.dist-info}/RECORD

@@ -20,7 +20,7 @@ coach_wizards/refactoring_wizard.py,sha256=X0MTx3BHpOlOMAYDow-3HX5GyryY70JGAF5vA
 coach_wizards/scaling_wizard.py,sha256=n1RLtpWmj1RSEGSWssMiUPwCdpskO3z2Z3yhLlTdXro,2598
 coach_wizards/security_wizard.py,sha256=19SOClSxo6N-QqUc_QsFXOE7yEquiZF4kLi7jRomA7g,2605
 coach_wizards/testing_wizard.py,sha256=vKFgFG4uJfAVFmCIQbkrWNvZhIfLC6ve_XbvWZKrPg4,2563
-empathy_framework-4.5.1.dist-info/licenses/LICENSE,sha256=IJ9eeI5KSrD5P7alsn7sI_6_1bDihxBA5S4Sen4jf2k,4937
+empathy_framework-4.6.0.dist-info/licenses/LICENSE,sha256=IJ9eeI5KSrD5P7alsn7sI_6_1bDihxBA5S4Sen4jf2k,4937
 empathy_healthcare_plugin/__init__.py,sha256=4NioL1_86UXzkd-QNkQZUSZ8rKTQGSP0TC9VXP32kQs,295
 empathy_healthcare_plugin/monitors/__init__.py,sha256=Udp8qfZR504QAq5_eQjvtIaE7v06Yguc7nuF40KllQc,196
 empathy_healthcare_plugin/monitors/clinical_protocol_monitor.py,sha256=MWE5t8tW9HWZn_SNo-inx8-0nhdTNGhbcB8ZeDWyXa0,11648
@@ -95,7 +95,7 @@ empathy_llm_toolkit/wizards/healthcare_wizard.py,sha256=B3NP7vYO2G4_TBgBxBX86OPc
 empathy_llm_toolkit/wizards/patient_assessment_README.md,sha256=DInK_x7LgM8Qi9YSHgXtm7_sQupioJRf0M43_vml4ck,1586
 empathy_llm_toolkit/wizards/patient_assessment_wizard.py,sha256=dsvoOq0AYCBigmn6HPoaSBnBPk9YV7IzAFZkJYx1iZQ,5423
 empathy_llm_toolkit/wizards/technology_wizard.py,sha256=1c_7UQ8I64vib2eogDbHlVqfWzZVlqtHyhZ8SQKqb_M,8061
-empathy_os/__init__.py,sha256=CD2DCQg7FdfwmFCF-sO7lNGBYFMOX3Dm1-okYjUPLyc,5896
+empathy_os/__init__.py,sha256=kIfkC5EjEoMqUFQreDfbUzNsSIgqBNwYShMSM6mMG2I,5896
 empathy_os/agent_monitoring.py,sha256=s4seLC_J4AtQ3PYWrRPO8YHM-Fbm0Q36kPEdlTHf2HI,13375
 empathy_os/cache_monitor.py,sha256=DTR8xr9d63czGzzdfrBFWp8hkoWPFsL-hpihPGmkbEc,11072
 empathy_os/cache_stats.py,sha256=rWJPBNFEfhuLwKYKy89D_Qa9GPIyVso2jdCKp_cdJhI,10232
@@ -163,11 +163,12 @@ empathy_os/memory/storage/__init__.py,sha256=sPLdecYJ1z6nZTIl8gmbozjdCPp0SZLKsKo
 empathy_os/meta_workflows/__init__.py,sha256=REUdSgr5kRxPuzj1R3qy50_BEdImoNOry_UNwn2jRYo,1845
 empathy_os/meta_workflows/agent_creator.py,sha256=f2Bc_Qm4bj7DFpGzhDf41RnUK4rG4jQRpRWYiQ_AdjE,8061
 empathy_os/meta_workflows/builtin_templates.py,sha256=5yL7hEKi7hu20jQK3PxJkGfwppyqdEokJiJMnTzTiXk,20722
-empathy_os/meta_workflows/cli_meta_workflows.py,sha256=ICKl50NI9K5RafWmUwvji_bk8xFyHscEo_3e0LALLOQ,58750
+empathy_os/meta_workflows/cli_meta_workflows.py,sha256=XeKfcJQIZKh6gz6Szx5FnZ9josStBJ0LJiazyrQGCEY,64088
 empathy_os/meta_workflows/form_engine.py,sha256=tUeSU_TofTS7ZjhWL5tIw4DxrleaHfFQf2mMDI4IaMg,10877
 empathy_os/meta_workflows/intent_detector.py,sha256=heWc6nm-EyMz-Ru2TfaNnWSLqduhOxfTVK80Plf96y4,10126
 empathy_os/meta_workflows/models.py,sha256=jtuAgSuY-vHbjqVOo4AIoq1SXfp-DxUhPyAcmwqjbcI,18909
-empathy_os/meta_workflows/pattern_learner.py,sha256=9DA6L39zu88ohu5zC9PmmJPaIb15of6GwFP7qyy1SlE,26529
+empathy_os/meta_workflows/pattern_learner.py,sha256=vvcYBpi16jaejPh4hgeHq78BKgi7on-ltgon5PuEvnI,26661
+empathy_os/meta_workflows/plan_generator.py,sha256=K0v3nVO4U7fJRylka53sg-qo4TEnK7VklLWWnOaLOKk,11020
 empathy_os/meta_workflows/session_context.py,sha256=WTdhWAKHq6cLJBLHT-jwjxOwQyUPId_F8GPjQlI7gvY,12366
 empathy_os/meta_workflows/template_registry.py,sha256=eFv4rlHcsuk7tnpLCjTNytYipmgyuruW_VZKdXmSXSE,7488
 empathy_os/meta_workflows/workflow.py,sha256=Sag47KtDACEAcFnQ30Lu834iNHo08GCx5dnMXL0ILcc,36015
@@ -233,9 +234,9 @@ empathy_os/scaffolding/README.md,sha256=VwSG36Cr0WH8Gep1-Dd9tPEzRLCra1KhqsNJQnjb
 empathy_os/scaffolding/__init__.py,sha256=-fqOQ0E3lb--D-0vic8d_1I1xiHeJiyKEHWpZvhz-Rk,977
 empathy_os/scaffolding/__main__.py,sha256=r-lWXicNLuTgliqw28yDV3PxX8SdX8fg4jm55RxmElo,280
 empathy_os/scaffolding/cli.py,sha256=2UxU_JUgtAuCkMXe9f2zYFbkMMtjk5DIOae5NjPC3yo,6700
-empathy_os/socratic/__init__.py,sha256=HEj8vxokJmr2bRWyNP5QUGy1toG7QyVG2u3T5FbXQWM,6097
+empathy_os/socratic/__init__.py,sha256=A5Z7JW6-dioFqwsI_CkS-yYzm3M2u3SxIW3-XQWqXdQ,6065
 empathy_os/socratic/ab_testing.py,sha256=uXRT1EhfDrDaqFJ0xI_C7K6bXEZ1b9Pj9F97q-bQLgk,30043
-empathy_os/socratic/blueprint.py,sha256=AvvXxxKuu8gmcKL4_gB1YonkgF3IzXfyZ_82WVF5E78,17147
+empathy_os/socratic/blueprint.py,sha256=EaBy4sDgmVwcMBXlvXFjKJeUegRJ4dliTLD-UuARSHI,17212
 empathy_os/socratic/cli.py,sha256=-RR90BY4oXrgBPeuN6nXP30TXtvEliWki2SfJNRibPg,21103
 empathy_os/socratic/collaboration.py,sha256=TpQRP0OHmCOWPDnQALmvZMYm6CNPGeFv2GgIJJzDcOU,33000
 empathy_os/socratic/domain_templates.py,sha256=-qh-I8CemX-XkSDnki7VxlMvtpI1lgzDQ3OZto0sP9U,30138
@@ -250,7 +251,7 @@ empathy_os/socratic/mcp_server.py,sha256=HqziHg1TQcQk_jDyJY9wOG0OJGzdfUgbzh62xKO
 empathy_os/socratic/session.py,sha256=9bwxlZpNaX1TiZEEPcN9uHCM5vWGcZqw9uGv5lrqYaU,9957
 empathy_os/socratic/storage.py,sha256=x-17Nng2O5ghOX6j_5muZyoDCmAovClhT1gv2p0uBnQ,21054
 empathy_os/socratic/success.py,sha256=8-EEyfRu_z9C14OSOJqzyBPEgq4fxKTEcnS81YGPFxc,24510
-empathy_os/socratic/visual_editor.py,sha256=gRxJTZfO4jHziC3iNhY6SwZxApmKVn6niQObZhQP23k,25653
+empathy_os/socratic/visual_editor.py,sha256=3GN_fnV2gE82ACVMq33dcHIfmTdi4eGk08mdwSgwbXg,25541
 empathy_os/socratic/web_ui.py,sha256=jW66CXea_dA-Kcj0ac6pCT9QuufmymXahzBDdJQXiNI,24760
 empathy_os/telemetry/__init__.py,sha256=6ZFO0r4I-WIE9BByVsKwyGFsGg-UEy3-OZNofHSr54A,263
 empathy_os/telemetry/cli.py,sha256=F-PktRoYEIzCrtoWLNZgKWvI0RzvC7YQagiDbmcXcfE,47167
@@ -326,7 +327,7 @@ empathy_os/workflows/progressive/core.py,sha256=891OttvWkFokBRVzvqVUxwpcNlgc7edl
 empathy_os/workflows/progressive/orchestrator.py,sha256=FsLcoRC8jujRcOV87PyN-0jzlLvStIQQqMFisxWWg0I,26786
 empathy_os/workflows/progressive/reports.py,sha256=F2p3HyInGH8fT9-e_BsOVcgeQBtOugYsSyBn49yhhmc,17588
 empathy_os/workflows/progressive/telemetry.py,sha256=5ZjCmeGjtfESejocWdtvnm5iCTAQv5_3NRTYmuoIbVs,9427
-empathy_os/workflows/progressive/test_gen.py,sha256=rNjjrQ8AFoXRe99X1Yk020gX6tcTxLh5pGMXXho8XRs,15802
+empathy_os/workflows/progressive/test_gen.py,sha256=K3AJ8cgNw-uiw3EZpl-19ldWFEL7l6xHKbL-1ZvD8Yo,15894
 empathy_os/workflows/progressive/workflow.py,sha256=bGXKmB9UFLfDw5c9MsW6Zw4GSbknCP-9HnaIEX36nhY,21597
 empathy_software_plugin/SOFTWARE_PLUGIN_README.md,sha256=RXIOB9Mt-8JrfGAA3ZUuRPT34sThubrwUgg5iNcSKIc,22591
 empathy_software_plugin/__init__.py,sha256=OceDhLoQrjD0jTPlI4418608l97OT48u4SCL5yEDPQc,309
@@ -395,8 +396,8 @@ workflow_scaffolding/__init__.py,sha256=UpX5vjjjPjIaAKyIV1D4GxJzLUZy5DzdzgSkePYM
 workflow_scaffolding/__main__.py,sha256=0qspuNoadTDqyskXTlT8Sahqau-XIxN35NHTSGVW6z4,236
 workflow_scaffolding/cli.py,sha256=yLgvMsPbqI-LHt7UKXMuj-Dc0-44EqWiChldysrw1YQ,6763
 workflow_scaffolding/generator.py,sha256=9eEmm324kVzf8BCtXEML090pyke06o0U7aGATzZIaPM,8869
-empathy_framework-4.5.1.dist-info/METADATA,sha256=rubJMu0yJFywjzRr-z18oEoBNxNyV0V-0_nZMj12vxI,57808
-empathy_framework-4.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-empathy_framework-4.5.1.dist-info/entry_points.txt,sha256=41rM9JgcKpkU8dr4VvPcbiPy2GQX68cEj10l3XMH0FQ,1519
-empathy_framework-4.5.1.dist-info/top_level.txt,sha256=wrNU1aVMutVDACer58H-udv0P_171Dv6z_42sZtZ-xM,124
-empathy_framework-4.5.1.dist-info/RECORD,,
+empathy_framework-4.6.0.dist-info/METADATA,sha256=TRZ-inv-0V9uIFrO6bStQ9sRJnRMzP5c5Cv_fR6GvDw,59411
+empathy_framework-4.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+empathy_framework-4.6.0.dist-info/entry_points.txt,sha256=41rM9JgcKpkU8dr4VvPcbiPy2GQX68cEj10l3XMH0FQ,1519
+empathy_framework-4.6.0.dist-info/top_level.txt,sha256=wrNU1aVMutVDACer58H-udv0P_171Dv6z_42sZtZ-xM,124
+empathy_framework-4.6.0.dist-info/RECORD,,

empathy_os/__init__.py

@@ -55,7 +55,7 @@ Copyright 2025 Smart AI Memory, LLC
 Licensed under Fair Source 0.9
 """
 
-__version__ = "4.1.1"
+__version__ = "4.6.0"
 __author__ = "Patrick Roebuck"
 __email__ = "hello@deepstudy.ai"
 

empathy_os/meta_workflows/cli_meta_workflows.py

@@ -215,6 +215,145 @@ def inspect_template(
         raise typer.Exit(code=1)
 
 
+# =============================================================================
+# Plan Generation Commands (Claude Code Integration)
+# =============================================================================
+
+
+@meta_workflow_app.command("plan")
+def generate_plan_cmd(
+    template_id: str = typer.Argument(..., help="Template ID to generate plan for"),
+    output_format: str = typer.Option(
+        "markdown",
+        "--format",
+        "-f",
+        help="Output format: markdown, skill, or json",
+    ),
+    output_file: str = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Output file path (default: stdout)",
+    ),
+    use_defaults: bool = typer.Option(
+        True,
+        "--use-defaults/--interactive",
+        help="Use default values or ask interactively",
+    ),
+    install_skill: bool = typer.Option(
+        False,
+        "--install",
+        "-i",
+        help="Install as Claude Code skill in .claude/commands/",
+    ),
+):
+    """Generate execution plan for Claude Code (no API costs).
+
+    This generates a plan that can be executed by Claude Code using your
+    Max subscription instead of making API calls.
+
+    Output formats:
+    - markdown: Human-readable plan to paste into Claude Code
+    - skill: Claude Code skill format for .claude/commands/
+    - json: Structured format for programmatic use
+
+    Examples:
+        empathy meta-workflow plan release-prep
+        empathy meta-workflow plan release-prep --format skill --install
+        empathy meta-workflow plan test-coverage-boost -o plan.md
+        empathy meta-workflow plan manage-docs --format json
+    """
+    try:
+        from empathy_os.meta_workflows.plan_generator import generate_plan
+
+        # Load template
+        console.print(f"\n[bold]Generating plan for:[/bold] {template_id}")
+        registry = TemplateRegistry()
+        template = registry.load_template(template_id)
+
+        if not template:
+            console.print(f"[red]Template not found:[/red] {template_id}")
+            raise typer.Exit(code=1)
+
+        # Collect responses if interactive
+        form_responses = None
+        if not use_defaults and template.form_schema.questions:
+            console.print("\n[bold]Configuration:[/bold]")
+            form_responses = {}
+            for question in template.form_schema.questions:
+                if question.options:
+                    # Multiple choice
+                    console.print(f"\n{question.text}")
+                    for i, opt in enumerate(question.options, 1):
+                        default_mark = " (default)" if opt == question.default else ""
+                        console.print(f"  {i}. {opt}{default_mark}")
+                    choice = typer.prompt("Choice", default="1")
+                    try:
+                        idx = int(choice) - 1
+                        form_responses[question.id] = question.options[idx]
+                    except (ValueError, IndexError):
+                        form_responses[question.id] = question.default or question.options[0]
+                else:
+                    # Yes/No or text
+                    default = question.default or "Yes"
+                    response = typer.prompt(question.text, default=default)
+                    form_responses[question.id] = response
+
+        # Generate plan
+        plan_content = generate_plan(
+            template_id=template_id,
+            form_responses=form_responses,
+            use_defaults=use_defaults,
+            output_format=output_format,
+        )
+
+        # Handle output
+        if install_skill:
+            # Install as Claude Code skill
+            skill_dir = Path(".claude/commands")
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            skill_path = skill_dir / f"{template_id}.md"
+
+            # Convert to skill format if not already
+            if output_format != "skill":
+                plan_content = generate_plan(
+                    template_id=template_id,
+                    form_responses=form_responses,
+                    use_defaults=use_defaults,
+                    output_format="skill",
+                )
+
+            skill_path.write_text(plan_content)
+            console.print(f"\n[green]✓ Installed as Claude Code skill:[/green] {skill_path}")
+            console.print(f"\nRun with: [bold]/project:{template_id}[/bold]")
+
+        elif output_file:
+            # Write to file
+            Path(output_file).write_text(plan_content)
+            console.print(f"\n[green]✓ Plan saved to:[/green] {output_file}")
+
+        else:
+            # Print to stdout
+            console.print("\n" + "=" * 60)
+            console.print(plan_content)
+            console.print("=" * 60)
+
+        # Show usage hints
+        console.print("\n[bold]Usage Options:[/bold]")
+        console.print("1. Copy prompts into Claude Code conversation")
+        console.print("2. Install as skill with: --install")
+        console.print("3. Use with Claude Code Task tool")
+        console.print("\n[dim]Cost: $0 (uses your Max subscription)[/dim]")
+
+    except ImportError:
+        console.print("[red]Plan generator not available.[/red]")
+        console.print("This feature requires the plan_generator module.")
+        raise typer.Exit(code=1)
+    except Exception as e:
+        console.print(f"[red]Error generating plan:[/red] {e}")
+        raise typer.Exit(code=1)
+
+
 # =============================================================================
 # Execution Commands
 # =============================================================================
@@ -459,7 +598,6 @@ def natural_language_run(
             console.print(f"[bold]Running {best_match.template_id}...[/bold]\n")
 
             # Run the workflow
-            ctx = typer.Context(run_workflow)
             run_workflow(
                 template_id=best_match.template_id,
                 mock=mock,

empathy_os/meta_workflows/pattern_learner.py

@@ -21,6 +21,8 @@ from empathy_os.meta_workflows.workflow import list_execution_results, load_exec
 
 if TYPE_CHECKING:
     from empathy_os.memory.unified import UnifiedMemory
+    from empathy_os.meta_workflows.models import FormResponse
+    from empathy_os.meta_workflows.workflow import MetaWorkflowResult
 
 logger = logging.getLogger(__name__)
 

empathy_os/meta_workflows/plan_generator.py

@@ -0,0 +1,376 @@
+"""Plan Generator for Meta-Workflows.
+
+Generates execution plans from meta-workflow templates that can be executed
+by Claude Code instead of making direct API calls.
+
+This enables users to leverage their Claude Max subscription instead of
+paying per-API-call costs.
+
+Output formats:
+- Markdown: Human-readable plan for interactive use
+- Claude Code Skill: .claude/commands/ compatible format
+- JSON: Programmatic consumption
+
+Created: 2026-01-20
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Literal
+
+from empathy_os.meta_workflows.models import (
+    AgentCompositionRule,
+    MetaWorkflowTemplate,
+    TierStrategy,
+)
+from empathy_os.orchestration.agent_templates import get_template
+
+
+@dataclass
+class AgentStep:
+    """A single step in the execution plan."""
+
+    order: int
+    role: str
+    tier_recommendation: str
+    tools: list[str]
+    prompt: str
+    success_criteria: list[str]
+    config: dict
+
+
+@dataclass
+class ExecutionPlan:
+    """Complete execution plan for a meta-workflow."""
+
+    template_id: str
+    template_name: str
+    generated_at: str
+    form_responses: dict
+    steps: list[AgentStep]
+    synthesis_prompt: str
+
+
+class PlanGenerator:
+    """Generates execution plans from meta-workflow templates."""
+
+    # Map tier strategies to Claude Code model recommendations
+    TIER_TO_MODEL = {
+        TierStrategy.CHEAP_ONLY: "haiku",
+        TierStrategy.PROGRESSIVE: "sonnet (escalate to opus if needed)",
+        TierStrategy.CAPABLE_FIRST: "sonnet",
+        TierStrategy.PREMIUM_ONLY: "opus",
+    }
+
+    def __init__(self, template: MetaWorkflowTemplate):
+        """Initialize with a template.
+
+        Args:
+            template: The meta-workflow template to generate a plan from
+        """
+        self.template = template
+
+    def generate(
+        self,
+        form_responses: dict | None = None,
+        use_defaults: bool = True,
+    ) -> ExecutionPlan:
+        """Generate an execution plan.
+
+        Args:
+            form_responses: User responses to form questions
+            use_defaults: Whether to use default values for missing responses
+
+        Returns:
+            ExecutionPlan ready for execution
+        """
+        # Collect form responses
+        responses = self._collect_responses(form_responses, use_defaults)
+
+        # Build steps from composition rules
+        steps = self._build_steps(responses)
+
+        # Generate synthesis prompt
+        synthesis = self._build_synthesis_prompt(steps)
+
+        return ExecutionPlan(
+            template_id=self.template.template_id,
+            template_name=self.template.name,
+            generated_at=datetime.now().isoformat(),
+            form_responses=responses,
+            steps=steps,
+            synthesis_prompt=synthesis,
+        )
+
+    def _collect_responses(
+        self,
+        provided: dict | None,
+        use_defaults: bool,
+    ) -> dict:
+        """Collect form responses with defaults."""
+        responses = {}
+        provided = provided or {}
+
+        for question in self.template.form_schema.questions:
+            if question.id in provided:
+                responses[question.id] = provided[question.id]
+            elif use_defaults and question.default:
+                responses[question.id] = question.default
+            elif question.required:
+                raise ValueError(f"Missing required response: {question.id}")
+
+        return responses
+
+    def _build_steps(self, responses: dict) -> list[AgentStep]:
+        """Build execution steps from composition rules."""
+        steps = []
+        order = 1
+
+        for rule in self.template.agent_composition_rules:
+            # Check if this agent should be included based on responses
+            if not self._should_include_agent(rule, responses):
+                continue
+
+            # Get base template for additional context
+            base_template = get_template(rule.base_template)
+
+            # Build the prompt
+            prompt = self._build_agent_prompt(rule, base_template, responses)
+
+            # Map config from responses
+            config = {}
+            for response_key, config_key in rule.config_mapping.items():
+                if response_key in responses:
+                    config[config_key] = responses[response_key]
+
+            steps.append(
+                AgentStep(
+                    order=order,
+                    role=rule.role,
+                    tier_recommendation=self.TIER_TO_MODEL.get(
+                        rule.tier_strategy, "sonnet"
+                    ),
+                    tools=rule.tools,
+                    prompt=prompt,
+                    success_criteria=rule.success_criteria,
+                    config=config,
+                )
+            )
+            order += 1
+
+        return steps
+
+    def _should_include_agent(
+        self,
+        rule: AgentCompositionRule,
+        responses: dict,
+    ) -> bool:
+        """Check if agent should be included based on required responses."""
+        for key, required_value in rule.required_responses.items():
+            if responses.get(key) != required_value:
+                return False
+        return True
+
+    def _build_agent_prompt(
+        self,
+        rule: AgentCompositionRule,
+        base_template,
+        responses: dict,
+    ) -> str:
+        """Build the prompt for an agent."""
+        # Start with base template instructions
+        base_instructions = ""
+        if base_template:
+            base_instructions = base_template.default_instructions
+
+        # Build context from responses
+        context_lines = []
+        for key, value in rule.config_mapping.items():
+            if key in responses:
+                context_lines.append(f"- {value}: {responses[key]}")
+
+        context = "\n".join(context_lines) if context_lines else "Using default configuration."
+
+        # Build success criteria checklist
+        criteria = "\n".join(f"- [ ] {c}" for c in rule.success_criteria)
+
+        return f"""You are a {rule.role} analyzing this codebase.
+
+{base_instructions}
+
+Configuration:
+{context}
+
+Success Criteria:
+{criteria}
+
+Tools available: {', '.join(rule.tools)}
+
+Provide a structured report with findings, issues by severity, and recommendations.
+"""
+
+    def _build_synthesis_prompt(self, steps: list[AgentStep]) -> str:
+        """Build the synthesis prompt that combines all agent outputs."""
+        roles = [f"- {step.role}" for step in steps]
+        roles_list = "\n".join(roles)
+
+        return f"""You are synthesizing the results from multiple agents.
+
+Combine the outputs from:
+{roles_list}
+
+Create a comprehensive report:
+
+## Summary
+Overall assessment of the analysis.
+
+## Critical Issues (must address)
+List any blockers or critical problems.
+
+## Recommendations (should address)
+List improvements and fixes.
+
+## Action Items
+Prioritized list of next steps.
+
+## Risk Assessment
+What risks exist? What's the recommended path forward?
+"""
+
+    def to_markdown(self, plan: ExecutionPlan) -> str:
+        """Convert plan to markdown format."""
+        lines = [
+            f"# Execution Plan: {plan.template_name}",
+            "",
+            "> Generated by Empathy Framework",
+            f"> Template: {plan.template_id}",
+            f"> Generated: {plan.generated_at}",
+            "",
+            "## Configuration",
+            "",
+        ]
+
+        for key, value in plan.form_responses.items():
+            lines.append(f"- **{key}**: {value}")
+
+        lines.extend(["", "---", "", "## Execution Steps", ""])
+
+        for step in plan.steps:
+            lines.extend([
+                f"### Step {step.order}: {step.role}",
+                "",
+                f"**Tier Recommendation**: {step.tier_recommendation}",
+                f"**Tools**: {', '.join(step.tools)}",
+                "",
+                "**Prompt:**",
+                "```",
+                step.prompt,
+                "```",
+                "",
+                "**Success Criteria:**",
+            ])
+            for criterion in step.success_criteria:
+                lines.append(f"- [ ] {criterion}")
+            lines.extend(["", "---", ""])
+
+        lines.extend([
+            "## Synthesis",
+            "",
+            "After all steps complete, run this synthesis:",
+            "",
+            "```",
+            plan.synthesis_prompt,
+            "```",
+        ])
+
+        return "\n".join(lines)
+
+    def to_claude_code_skill(self, plan: ExecutionPlan) -> str:
+        """Convert plan to Claude Code skill format.
+
+        This generates content for .claude/commands/<template-id>.md
+        """
+        steps_text = []
+        for step in plan.steps:
+            steps_text.append(f"""
+### {step.role}
+Use the Task tool with subagent_type="Explore" to:
+{step.prompt}
+""")
+
+        return f"""# {plan.template_name}
+
+Execute the {plan.template_name} workflow for this codebase.
+
+## Steps
+
+{"".join(steps_text)}
+
+## Synthesis
+
+After completing all steps, synthesize the findings:
+{plan.synthesis_prompt}
+
+## Output
+
+Provide a final report with:
+1. Overall status (READY / NEEDS WORK / BLOCKED)
+2. Critical issues found
+3. Recommendations
+4. Next steps
+"""
+
+
+def generate_plan(
+    template_id: str,
+    form_responses: dict | None = None,
+    use_defaults: bool = True,
+    output_format: Literal["markdown", "skill", "json"] = "markdown",
+) -> str:
+    """Generate an execution plan for a meta-workflow.
+
+    Args:
+        template_id: ID of the template to use
+        form_responses: Optional form responses
+        use_defaults: Whether to use default values
+        output_format: Output format (markdown, skill, or json)
+
+    Returns:
+        Plan in the requested format
+    """
+    from empathy_os.meta_workflows.registry import get_template as get_workflow_template
+
+    template = get_workflow_template(template_id)
+    if not template:
+        raise ValueError(f"Template not found: {template_id}")
+
+    generator = PlanGenerator(template)
+    plan = generator.generate(form_responses, use_defaults)
+
+    if output_format == "markdown":
+        return generator.to_markdown(plan)
+    elif output_format == "skill":
+        return generator.to_claude_code_skill(plan)
+    elif output_format == "json":
+        import json
+        return json.dumps({
+            "template_id": plan.template_id,
+            "template_name": plan.template_name,
+            "generated_at": plan.generated_at,
+            "form_responses": plan.form_responses,
+            "steps": [
+                {
+                    "order": s.order,
+                    "role": s.role,
+                    "tier_recommendation": s.tier_recommendation,
+                    "tools": s.tools,
+                    "prompt": s.prompt,
+                    "success_criteria": s.success_criteria,
+                    "config": s.config,
+                }
+                for s in plan.steps
+            ],
+            "synthesis_prompt": plan.synthesis_prompt,
+        }, indent=2)
+    else:
+        raise ValueError(f"Unknown format: {output_format}")

empathy_os/socratic/__init__.py

@@ -51,7 +51,7 @@ from .blueprint import (
 )
 
 # CLI interface
-from .cli import Console, SocraticCLI
+from .cli import Console
 
 # Collaboration
 from .collaboration import (
@@ -199,7 +199,6 @@ __all__ = [
     "SQLiteStorage",
     "StorageManager",
     # CLI interface
-    "SocraticCLI",
     "Console",
     # Web UI components
     "ReactFormSchema",

empathy_os/socratic/blueprint.py

@@ -28,6 +28,7 @@ class AgentRole(Enum):
     ANALYZER = "analyzer"  # Examines input, identifies patterns
     REVIEWER = "reviewer"  # Evaluates quality, finds issues
     AUDITOR = "auditor"  # Deep-dive security/compliance checks
+    RESEARCHER = "researcher"  # Gathers information and context
 
     # Action agents
     GENERATOR = "generator"  # Creates new content/code

empathy_os/socratic/visual_editor.py

@@ -265,9 +265,6 @@ class WorkflowVisualizer:
         stage_nodes = [n for n in state.nodes if n.node_type == NodeType.STAGE]
         agent_nodes = [n for n in state.nodes if n.node_type == NodeType.AGENT]
 
-        # Build agent lookup from original
-        agents_by_id = {a.agent_id: a for a in original_blueprint.agents}
-
         # Build edge lookup
         edges_by_source: dict[str, list[str]] = {}
         edges_by_target: dict[str, list[str]] = {}
@@ -410,8 +407,8 @@ class ASCIIVisualizer:
         stages = []
         for stage in blueprint.stages:
             agents = ",".join(a[:8] for a in stage.agent_ids)
-            parallel = "∥" if stage.parallel else "→"
-            stages.append(f"[{stage.name}:{agents}]")
+            marker = "∥" if stage.parallel else "→"
+            stages.append(f"[{stage.name}{marker}:{agents}]")
 
         return f" {' → '.join(stages)} "
 

empathy_os/workflows/progressive/test_gen.py

@@ -163,15 +163,15 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
         """
         logger.info(f"Generating {len(items)} tests at {tier.value} tier")
 
-        # Build prompt for this tier
+        # Build prompt for this tier (prepared for future LLM integration)
         base_task = self._build_test_gen_task(items)
-        prompt = self.meta_orchestrator.build_tier_prompt(
+        _prompt = self.meta_orchestrator.build_tier_prompt(  # noqa: F841
             tier,
             base_task,
             context
         )
 
-        # TODO: Call LLM API with prompt
+        # TODO: Call LLM API with _prompt
         # For now, simulate test generation
         generated_tests = self._simulate_test_generation(tier, items)
 
@@ -228,8 +228,8 @@ class ProgressiveTestGenWorkflow(ProgressiveWorkflow):
         """
         generated_tests = []
 
-        # Simulate different quality levels per tier
-        base_quality = {
+        # Quality thresholds per tier (prepared for future LLM integration)
+        _base_quality = {  # noqa: F841
             Tier.CHEAP: 70,
             Tier.CAPABLE: 85,
             Tier.PREMIUM: 95