feat: implement LLM decomposition strategy and workspace isolation

CLAUDE.md

@@ -49,7 +49,7 @@ src/ai_company/
   communication/  # Message bus, dispatcher, messenger, channels, delegation, loop prevention, conflict resolution, meeting protocol
   config/         # YAML company config loading and validation
   core/           # Shared domain models and base classes
-  engine/         # Agent orchestration, execution loops, parallel execution, task decomposition, routing, task assignment, task lifecycle, recovery, and shutdown
+  engine/         # Agent orchestration, execution loops, parallel execution, task decomposition, routing, task assignment, task lifecycle, recovery, shutdown, and workspace isolation
   memory/         # Persistent agent memory (memory layer TBD)
   observability/  # Structured logging, correlation tracking, log sinks
   providers/      # LLM provider abstraction (LiteLLM adapter)

DESIGN_SPEC.md

@@ -1102,7 +1102,7 @@ On shutdown signal, each agent persists its full `AgentContext` snapshot and tra
 
 ### 6.8 Concurrent Workspace Isolation (M4+)
 
-> **MVP: Not applicable.** M3 is single-agent — no concurrent file edits are possible. This section defines the M4+ strategy for multi-agent workspace coordination.
+> **Current state:** The `WorkspaceIsolationStrategy` protocol, `PlannerWorktreeStrategy` (git worktree backend), `MergeOrchestrator` (sequential merge with configurable conflict escalation), and `WorkspaceIsolationService` (lifecycle orchestrator with rollback and best-effort teardown) are implemented in `engine/workspace/`. Runtime multi-agent coordination using these components is M4+.
 
 When multiple agents work on the same codebase concurrently, they may need to edit overlapping files. The framework provides a pluggable `WorkspaceIsolationStrategy` protocol for managing concurrent file access. The default strategy combines intelligent task decomposition with git worktree isolation — the dominant industry pattern (used by OpenAI Codex, Cursor, Claude Code, VS Code background agents).
 
@@ -1161,7 +1161,7 @@ These are complementary systems handling different types of shared state:
 
 ### 6.9 Task Decomposability & Coordination Topology (M4+)
 
-> **Current state:** Task structure classification (`TaskStructureClassifier`), DAG-based decomposition (`DecompositionService`, `DependencyGraph`, `ManualDecompositionStrategy`), status rollup (`StatusRollup`), agent-task scoring (`AgentTaskScorer`), routing (`TaskRoutingService`), and auto topology selection (`TopologySelector`) are implemented in `engine/decomposition/` and `engine/routing/`. LLM-based decomposition strategies and runtime multi-agent coordination are M4+ (see #168).
+> **Current state:** Task structure classification (`TaskStructureClassifier`), DAG-based decomposition (`DecompositionService`, `DependencyGraph`, `ManualDecompositionStrategy`), LLM-based decomposition (`LlmDecompositionStrategy` with tool calling and JSON content fallback), status rollup (`StatusRollup`), agent-task scoring (`AgentTaskScorer`), routing (`TaskRoutingService`), and auto topology selection (`TopologySelector`) are implemented in `engine/decomposition/` and `engine/routing/`. Workspace isolation (`PlannerWorktreeStrategy`, `MergeOrchestrator`, `WorkspaceIsolationService`) is implemented in `engine/workspace/`. Runtime multi-agent coordination is M4+.
 
 Empirical research on agent scaling ([Kim et al., 2025](https://arxiv.org/abs/2512.08296) — 180 controlled experiments across 3 LLM families and 4 benchmarks) demonstrates that **task decomposability is the strongest predictor of multi-agent effectiveness** — stronger than team size, model capability, or coordination architecture.
 
@@ -2367,7 +2367,7 @@ ai-company/
 │       │   ├── role.py             # Role model
 │       │   ├── role_catalog.py     # Role catalog
 │       │   └── personality.py     # Personality compatibility scoring
-│       ├── engine/                  # Agent orchestration, execution loops, parallel execution, task decomposition, routing, task assignment, task lifecycle, recovery, and shutdown
+│       ├── engine/                  # Agent orchestration, execution loops, parallel execution, task decomposition, routing, task assignment, task lifecycle, recovery, shutdown, and workspace isolation
 │       │   ├── errors.py           # Engine error hierarchy
 │       │   ├── prompt.py           # System prompt builder
 │       │   ├── prompt_template.py  # System prompt Jinja2 templates
@@ -2398,11 +2398,21 @@ ai-company/
 │       │   │   ├── __init__.py    # Package exports
 │       │   │   ├── classifier.py  # TaskStructureClassifier (sequential/parallel/mixed)
 │       │   │   ├── dag.py         # DependencyGraph (validation, topo sort, parallel groups)
+│       │   │   ├── llm.py         # LlmDecompositionStrategy (LLM-based decomposition with tool calling)
+│       │   │   ├── llm_prompt.py  # Prompt building and response parsing for LLM decomposition
 │       │   │   ├── manual.py      # ManualDecompositionStrategy
 │       │   │   ├── models.py      # SubtaskDefinition, DecompositionPlan, DecompositionResult, SubtaskStatusRollup, DecompositionContext
 │       │   │   ├── protocol.py    # DecompositionStrategy protocol
 │       │   │   ├── rollup.py      # StatusRollup (compute subtask status aggregation)
 │       │   │   └── service.py     # DecompositionService (orchestrates strategy + classifier + DAG)
+│       │   ├── workspace/          # Workspace isolation subsystem (§6.8)
+│       │   │   ├── __init__.py    # Package exports
+│       │   │   ├── config.py      # PlannerWorktreesConfig, WorkspaceIsolationConfig
+│       │   │   ├── git_worktree.py # PlannerWorktreeStrategy (git worktree backend)
+│       │   │   ├── merge.py       # MergeOrchestrator (sequential merge with conflict escalation)
+│       │   │   ├── models.py      # Workspace, WorkspaceRequest, MergeResult, MergeConflict, WorkspaceGroupResult
+│       │   │   ├── protocol.py    # WorkspaceIsolationStrategy protocol
+│       │   │   └── service.py     # WorkspaceIsolationService (lifecycle orchestrator)
 │       │   ├── routing/            # Task routing subsystem
 │       │   │   ├── __init__.py    # Package exports
 │       │   │   ├── models.py      # RoutingCandidate, RoutingDecision, RoutingResult, AutoTopologyConfig
@@ -2501,7 +2511,8 @@ ai-company/
 │       │   │   ├── task_assignment.py # TASK_ASSIGNMENT_* constants
 │       │   │   ├── task_routing.py # TASK_ROUTING_* constants
 │       │   │   ├── template.py    # TEMPLATE_* constants
-│       │   │   └── tool.py        # TOOL_* constants
+│       │   │   ├── tool.py        # TOOL_* constants
+│       │   │   └── workspace.py   # WORKSPACE_* constants
 │       │   ├── processors.py       # Log processors
 │       │   ├── setup.py            # Logging setup
 │       │   └── sinks.py            # Log output backends

README.md

@@ -16,8 +16,9 @@ AI Company lets you spin up a virtual organization staffed entirely by AI agents
 - **Smart Cost Management** - Per-agent budget tracking, auto model routing, CFO agent optimization
 - **Hierarchical Delegation** - Chain-of-command task delegation with five-mechanism loop prevention
 - **Conflict Resolution** - Pluggable strategies for resolving agent disagreements (authority, debate, human escalation, hybrid) with dissent audit trail
-- **Task Decomposition & Routing** - DAG-based subtask decomposition, structure classification, and agent-task scoring
+- **Task Decomposition & Routing** - DAG-based and LLM-based subtask decomposition, structure classification, and agent-task scoring
 - **Task Assignment** - Pluggable strategies (manual, role-based, load-balanced) for matching tasks to capable agents
+- **Workspace Isolation** - Git worktree-based concurrent workspace isolation with sequential merge and conflict escalation
 - **Configurable Autonomy** - From fully autonomous to human-approves-everything, with a Security Ops agent in between
 - **Persistent Memory** - Agents remember past decisions, code, relationships (memory layer TBD)
 - **HR System** - Hire, fire, promote agents. HR agent analyzes skill gaps and proposes candidates

src/ai_company/core/enums.py

@@ -349,3 +349,33 @@ class ActionType(StrEnum):
     EXTERNAL_COMMUNICATION = "external_communication"
     HIRING = "hiring"
     ARCHITECTURE_CHANGE = "architecture_change"
+
+
+class MergeOrder(StrEnum):
+    """Order in which workspace branches are merged back.
+
+    Determines the sequence of merge operations when multiple
+    agent workspaces are being merged into the base branch.
+    """
+
+    COMPLETION = "completion"
+    PRIORITY = "priority"
+    MANUAL = "manual"
+
+
+class ConflictEscalation(StrEnum):
+    """Strategy for handling merge conflicts during workspace merges.
+
+    Controls whether merging stops for human review or continues
+    with an automated review agent flagging conflicts.
+    """
+
+    HUMAN = "human"
+    REVIEW_AGENT = "review_agent"
+
+
+class ConflictType(StrEnum):
+    """Type of merge conflict detected during workspace merges."""
+
+    TEXTUAL = "textual"
+    SEMANTIC = "semantic"

src/ai_company/engine/__init__.py

@@ -33,6 +33,8 @@
     DecompositionService,
     DecompositionStrategy,
     DependencyGraph,
+    LlmDecompositionConfig,
+    LlmDecompositionStrategy,
     ManualDecompositionStrategy,
     StatusRollup,
     SubtaskDefinition,
@@ -54,6 +56,11 @@
     ResourceConflictError,
     TaskAssignmentError,
     TaskRoutingError,
+    WorkspaceCleanupError,
+    WorkspaceError,
+    WorkspaceLimitError,
+    WorkspaceMergeError,
+    WorkspaceSetupError,
 )
 from ai_company.engine.loop_protocol import (
     BudgetChecker,
@@ -110,6 +117,19 @@
     ShutdownStrategy,
 )
 from ai_company.engine.task_execution import StatusTransition, TaskExecution
+from ai_company.engine.workspace import (
+    MergeConflict,
+    MergeOrchestrator,
+    MergeResult,
+    PlannerWorktreesConfig,
+    PlannerWorktreeStrategy,
+    Workspace,
+    WorkspaceGroupResult,
+    WorkspaceIsolationConfig,
+    WorkspaceIsolationService,
+    WorkspaceIsolationStrategy,
+    WorkspaceRequest,
+)
 from ai_company.providers.models import ZERO_TOKEN_USAGE, add_token_usage
 
 __all__ = [
@@ -152,11 +172,16 @@
     "ExecutionStateError",
     "FailAndReassignStrategy",
     "InMemoryResourceLock",
+    "LlmDecompositionConfig",
+    "LlmDecompositionStrategy",
     "LoadBalancedAssignmentStrategy",
     "LoopExecutionError",
     "ManualAssignmentStrategy",
     "ManualDecompositionStrategy",
     "MaxTurnsExceededError",
+    "MergeConflict",
+    "MergeOrchestrator",
+    "MergeResult",
     "NoEligibleAgentError",
     "ParallelExecutionError",
     "ParallelExecutionGroup",
@@ -166,6 +191,8 @@
     "PlanExecuteConfig",
     "PlanExecuteLoop",
     "PlanStep",
+    "PlannerWorktreeStrategy",
+    "PlannerWorktreesConfig",
     "ProgressCallback",
     "PromptBuildError",
     "PromptTokenEstimator",
@@ -199,6 +226,17 @@
     "TerminationReason",
     "TopologySelector",
     "TurnRecord",
+    "Workspace",
+    "WorkspaceCleanupError",
+    "WorkspaceError",
+    "WorkspaceGroupResult",
+    "WorkspaceIsolationConfig",
+    "WorkspaceIsolationService",
+    "WorkspaceIsolationStrategy",
+    "WorkspaceLimitError",
+    "WorkspaceMergeError",
+    "WorkspaceRequest",
+    "WorkspaceSetupError",
     "add_token_usage",
     "build_system_prompt",
 ]

src/ai_company/engine/decomposition/__init__.py

@@ -6,6 +6,10 @@
 
 from ai_company.engine.decomposition.classifier import TaskStructureClassifier
 from ai_company.engine.decomposition.dag import DependencyGraph
+from ai_company.engine.decomposition.llm import (
+    LlmDecompositionConfig,
+    LlmDecompositionStrategy,
+)
 from ai_company.engine.decomposition.manual import ManualDecompositionStrategy
 from ai_company.engine.decomposition.models import (
     DecompositionContext,
@@ -25,6 +29,8 @@
     "DecompositionService",
     "DecompositionStrategy",
     "DependencyGraph",
+    "LlmDecompositionConfig",
+    "LlmDecompositionStrategy",
     "ManualDecompositionStrategy",
     "StatusRollup",
     "SubtaskDefinition",