monoco-toolkit 0.1.1__py3-none-any.whl → 0.2.8__py3-none-any.whl

monoco/features/issue/core.py

@@ -6,16 +6,25 @@ from typing import List, Dict, Optional, Tuple, Any, Set, Set
 from datetime import datetime
 from .models import IssueMetadata, IssueType, IssueStatus, IssueSolution, IssueStage, IssueDetail, IsolationType, IssueIsolation, IssueID, current_time, generate_uid
 from monoco.core import git
-from monoco.core.config import get_config
+from monoco.core.config import get_config, MonocoConfig
+from monoco.core.lsp import DiagnosticSeverity
+from .validator import IssueValidator
 
-PREFIX_MAP = {
-    IssueType.EPIC: "EPIC",
-    IssueType.FEATURE: "FEAT",
-    IssueType.CHORE: "CHORE",
-    IssueType.FIX: "FIX"
-}
+from .engine import get_engine
 
-REVERSE_PREFIX_MAP = {v: k for k, v in PREFIX_MAP.items()}
+def get_prefix_map(issues_root: Path) -> Dict[str, str]:
+    engine = get_engine(str(issues_root.parent))
+    return engine.get_prefix_map()
+
+def get_reverse_prefix_map(issues_root: Path) -> Dict[str, str]:
+    prefix_map = get_prefix_map(issues_root)
+    return {v: k for k, v in prefix_map.items()}
+
+def get_issue_dir(issue_type: str, issues_root: Path) -> Path:
+    engine = get_engine(str(issues_root.parent))
+    folder_map = engine.get_folder_map()
+    folder = folder_map.get(issue_type, issue_type.capitalize() + "s")
+    return issues_root / folder
 
 def _get_slug(title: str) -> str:
     slug = title.lower()
@@ -29,15 +38,6 @@ def _get_slug(title: str) -> str:
         
     return slug
 
-def get_issue_dir(issue_type: IssueType, issues_root: Path) -> Path:
-    mapping = {
-        IssueType.EPIC: "Epics",
-        IssueType.FEATURE: "Features",
-        IssueType.CHORE: "Chores",
-        IssueType.FIX: "Fixes",
-    }
-    return issues_root / mapping[issue_type]
-
 def parse_issue(file_path: Path) -> Optional[IssueMetadata]:
     if not file_path.suffix == ".md":
         return None
@@ -51,7 +51,11 @@ def parse_issue(file_path: Path) -> Optional[IssueMetadata]:
         data = yaml.safe_load(match.group(1))
         if not isinstance(data, dict):
              return None
-        return IssueMetadata(**data)
+        
+        data['path'] = str(file_path.absolute())
+        meta = IssueMetadata(**data)
+        meta.actions = get_available_actions(meta)
+        return meta
     except Exception:
         return None
 
@@ -72,12 +76,15 @@ def parse_issue_detail(file_path: Path) -> Optional[IssueDetail]:
         data = yaml.safe_load(yaml_str)
         if not isinstance(data, dict):
              return None
+             
+        data['path'] = str(file_path.absolute())
         return IssueDetail(**data, body=body, raw_content=content)
     except Exception:
         return None
 
-def find_next_id(issue_type: IssueType, issues_root: Path) -> str:
-    prefix = PREFIX_MAP[issue_type]
+def find_next_id(issue_type: str, issues_root: Path) -> str:
+    prefix_map = get_prefix_map(issues_root)
+    prefix = prefix_map.get(issue_type, "ISSUE")
     pattern = re.compile(rf"{prefix}-(\d+)")
     max_id = 0
     
@@ -118,13 +125,35 @@ def create_issue_file(
 
     issue_id = find_next_id(issue_type, issues_root)
     base_type_dir = get_issue_dir(issue_type, issues_root)
-    target_dir = base_type_dir / status.value
+    target_dir = base_type_dir / status
     
     if subdir:
         target_dir = target_dir / subdir
         
     target_dir.mkdir(parents=True, exist_ok=True)
     
+    # Auto-Populate Tags with required IDs (Requirement: Maintain tags field with parent/deps/related/self IDs)
+    # Ensure they are prefixed with '#' for tagging convention if not present (usually tags are just strings, but user asked for #ID)
+    auto_tags = set(tags) if tags else set()
+    
+    # 1. Add Parent
+    if parent:
+        auto_tags.add(f"#{parent}")
+        
+    # 2. Add Dependencies
+    for dep in dependencies:
+        auto_tags.add(f"#{dep}")
+        
+    # 3. Add Related
+    for rel in related:
+        auto_tags.add(f"#{rel}")
+        
+    # 4. Add Self (as per instruction "auto add this issue... number")
+    # Note: issue_id is generated just above
+    auto_tags.add(f"#{issue_id}")
+    
+    final_tags = sorted(list(auto_tags))
+
     metadata = IssueMetadata(
         id=issue_id,
         uid=generate_uid(),  # Generate global unique identifier
@@ -136,85 +165,107 @@ def create_issue_file(
         dependencies=dependencies,
         related=related,
         sprint=sprint,
-        tags=tags,
+        tags=final_tags,
         opened_at=current_time() if status == IssueStatus.OPEN else None
     )
+    
+    # Enforce lifecycle policies (defaults, auto-corrections)
+    from .engine import get_engine
+    get_engine().enforce_policy(metadata)
 
+    # Serialize metadata
+    # Explicitly exclude actions and path from file persistence
+    yaml_header = yaml.dump(metadata.model_dump(exclude_none=True, mode='json', exclude={'actions', 'path'}), sort_keys=False, allow_unicode=True)
     
-    yaml_header = yaml.dump(metadata.model_dump(exclude_none=True, mode='json'), sort_keys=False, allow_unicode=True)
+    # Inject Self-Documenting Hints (Interactive Frontmatter)
+    if "parent:" not in yaml_header:
+        yaml_header += "# parent: <EPIC-ID>   # Optional: Parent Issue ID\n"
+    if "solution:" not in yaml_header:
+        yaml_header += "# solution: null      # Required for Closed state (implemented, cancelled, etc.)\n"
+
+    if "dependencies:" not in yaml_header:
+        yaml_header += "# dependencies: []    # List of dependency IDs\n"
+    if "related:" not in yaml_header:
+        yaml_header += "# related: []         # List of related issue IDs\n"
+    if "files:" not in yaml_header:
+        yaml_header += "# files: []           # List of modified files\n"
+
     slug = _get_slug(title)
     filename = f"{issue_id}-{slug}.md"
     
+    # Enhanced Template with Instructional Comments
     file_content = f"""---
 {yaml_header}---
 
 ## {issue_id}: {title}
 
 ## Objective
+<!-- Describe the "Why" and "What" clearly. Focus on value. -->
 
 ## Acceptance Criteria
+<!-- Define binary conditions for success. -->
+- [ ] Criteria 1
 
 ## Technical Tasks
+<!-- Breakdown into atomic steps. Use nested lists for sub-tasks. -->
 
-- [ ] 
+<!-- Status Syntax: -->
+<!-- [ ] To Do -->
+<!-- [/] Doing -->
+<!-- [x] Done -->
+<!-- [~] Cancelled -->
+<!-- - [ ] Parent Task -->
+<!--   - [ ] Sub Task -->
+
+- [ ] Task 1
+
+## Review Comments
+<!-- Required for Review/Done stage. Record review feedback here. -->
 """
     file_path = target_dir / filename
     file_path.write_text(file_content)
     
+    # Inject path into returned metadata
+    metadata.path = str(file_path.absolute())
+    
     return metadata, file_path
-def validate_transition(
-    current_status: IssueStatus,
-    current_stage: Optional[IssueStage],
-    target_status: IssueStatus,
-    target_stage: Optional[IssueStage],
-    target_solution: Optional[str],
-    issue_dependencies: List[str],
-    issues_root: Path,
-    issue_id: str
-):
-    """
-    Centralized validation logic for state transitions.
-    """
-    # Policy: Prevent Backlog -> Review
-    if target_stage == IssueStage.REVIEW and current_status == IssueStatus.BACKLOG:
-         raise ValueError(f"Lifecycle Policy: Cannot submit Backlog issue directly. Run `monoco issue pull {issue_id}` first.")
+def get_available_actions(meta: IssueMetadata) -> List[Any]:
+    from .models import IssueAction
+    from .engine import get_engine
+    
+    engine = get_engine()
+    transitions = engine.get_available_transitions(meta)
+    
+    actions = []
+    for t in transitions:
+        command = t.command_template.format(id=meta.id) if t.command_template else ""
+        
+        actions.append(IssueAction(
+            label=t.label,
+            icon=t.icon,
+            target_status=t.to_status if t.to_status != meta.status or t.to_stage != meta.stage else None,
+            target_stage=t.to_stage if t.to_stage != meta.stage else None,
+            target_solution=t.required_solution,
+            command=command
+        ))
 
-    if target_status == IssueStatus.CLOSED:
-        if not target_solution:
-            raise ValueError(f"Closing an issue requires a solution. Please provide --solution or edit the file metadata.")
-            
-        # Policy: IMPLEMENTED requires REVIEW stage (unless we are already in REVIEW)
-        # Check current stage.
-        if target_solution == IssueSolution.IMPLEMENTED.value:
-            # If we are transitioning FROM Review, it's fine.
-            # If we are transitioning TO Closed, current stage must be Review.
-            if current_stage != IssueStage.REVIEW:
-                raise ValueError(f"Lifecycle Policy: 'Implemented' issues must be submitted for review first.\nCurrent stage: {current_stage}\nAction: Run `monoco issue submit {issue_id}`.")
-
-        # Policy: No closing from DOING (General Safety)
-        if current_stage == IssueStage.DOING:
-             raise ValueError("Cannot close issue in progress (Doing). Please review (`monoco issue submit`) or stop (`monoco issue open`) first.")
-             
-        # Policy: Dependencies must be closed
-        if issue_dependencies:
-            for dep_id in issue_dependencies:
-                dep_path = find_issue_path(issues_root, dep_id)
-                if dep_path:
-                    dep_meta = parse_issue(dep_path)
-                    if dep_meta and dep_meta.status != IssueStatus.CLOSED:
-                        raise ValueError(f"Dependency Block: Cannot close {issue_id} because dependency {dep_id} is not closed.")
+    return actions
 
 def find_issue_path(issues_root: Path, issue_id: str) -> Optional[Path]:
     parsed = IssueID(issue_id)
 
     if not parsed.is_local:
+        if not parsed.namespace:
+            return None
+
         # Resolve Workspace
-        # Assumption: issues_root is direct child of project_root. 
-        # This is a weak assumption but fits current architecture.
+        # Traverse up from issues_root to find a config that defines the namespace
         project_root = issues_root.parent
-        conf = get_config(str(project_root))
         
+        # Try current root first
+        conf = MonocoConfig.load(str(project_root))
         member_rel_path = conf.project.members.get(parsed.namespace)
+        
         if not member_rel_path:
             return None
             
@@ -234,7 +285,8 @@ def find_issue_path(issues_root: Path, issue_id: str) -> Optional[Path]:
     except IndexError:
         return None
         
-    issue_type = REVERSE_PREFIX_MAP.get(prefix)
+    reverse_prefix_map = get_reverse_prefix_map(issues_root)
+    issue_type = reverse_prefix_map.get(prefix)
     if not issue_type:
         return None
         
@@ -244,7 +296,20 @@ def find_issue_path(issues_root: Path, issue_id: str) -> Optional[Path]:
         return f
     return None
 
-def update_issue(issues_root: Path, issue_id: str, status: Optional[IssueStatus] = None, stage: Optional[IssueStage] = None, solution: Optional[IssueSolution] = None) -> IssueMetadata:
+def update_issue(
+    issues_root: Path, 
+    issue_id: str, 
+    status: Optional[IssueStatus] = None, 
+    stage: Optional[IssueStage] = None, 
+    solution: Optional[IssueSolution] = None,
+    title: Optional[str] = None,
+    parent: Optional[str] = None,
+    sprint: Optional[str] = None,
+    dependencies: Optional[List[str]] = None,
+    related: Optional[List[str]] = None,
+    tags: Optional[List[str]] = None,
+    files: Optional[List[str]] = None
+) -> IssueMetadata:
     path = find_issue_path(issues_root, issue_id)
     if not path:
         raise FileNotFoundError(f"Issue {issue_id} not found.")
@@ -253,7 +318,7 @@ def update_issue(issues_root: Path, issue_id: str, status: Optional[IssueStatus]
     content = path.read_text()
     
     # Split Frontmatter and Body
-    match = re.search(r"^---(.*?)---\n(.*)$\n", content, re.DOTALL | re.MULTILINE)
+    match = re.search(r"^---(.*?)---\n(.*)\n", content, re.DOTALL | re.MULTILINE)
     if not match:
         # Fallback
         match_simple = re.search(r"^---(.*?)---", content, re.DOTALL | re.MULTILINE)
@@ -277,50 +342,100 @@ def update_issue(issues_root: Path, issue_id: str, status: Optional[IssueStatus]
         current_status = IssueStatus(current_status_str.lower())
     except ValueError:
         current_status = IssueStatus.OPEN
+    
+    current_stage_str = data.get("stage")
+    current_stage = IssueStage(current_stage_str.lower()) if current_stage_str else None
 
     # Logic: Status Update
     target_status = status if status else current_status
     
-    # Validation: For closing
-    effective_solution = solution.value if solution else data.get("solution")
+    # If status is changing, we don't default target_stage to current_stage
+    # because the new status might have different allowed stages.
+    # enforce_policy will handle setting the correct default stage for the new status.
+    if status and status != current_status:
+        target_stage = stage
+    else:
+        target_stage = stage if stage else current_stage
     
-    # Policy: Prevent Backlog -> Review
-    if stage == IssueStage.REVIEW and current_status == IssueStatus.BACKLOG:
-         raise ValueError(f"Lifecycle Policy: Cannot submit Backlog issue directly. Run `monoco issue pull {issue_id}` first.")
+    # Engine Validation
+    from .engine import get_engine
+    engine = get_engine()
+    
+    # Map solution string to enum if present
+    effective_solution = solution
+    if not effective_solution and data.get("solution"):
+        try:
+            effective_solution = IssueSolution(data.get("solution").lower())
+        except ValueError:
+            pass
 
-    if target_status == IssueStatus.CLOSED:
-        if not effective_solution:
-            raise ValueError(f"Closing an issue requires a solution. Please provide --solution or edit the file metadata.")
-            
-        current_data_stage = data.get('stage')
-        
-        # Policy: IMPLEMENTED requires REVIEW stage
-        if effective_solution == IssueSolution.IMPLEMENTED.value:
-            if current_data_stage != IssueStage.REVIEW.value:
-                raise ValueError(f"Lifecycle Policy: 'Implemented' issues must be submitted for review first.\nCurrent stage: {current_data_stage}\nAction: Run `monoco issue submit {issue_id}`.")
-
-     # Policy: No closing from DOING (General Safety)
-        if current_data_stage == IssueStage.DOING.value:
-             raise ValueError("Cannot close issue in progress (Doing). Please review (`monoco issue submit`) or stop (`monoco issue open`) first.")
-             
+    # Use engine to validate the transition
+    engine.validate_transition(
+        from_status=current_status,
+        from_stage=current_stage,
+        to_status=target_status,
+        to_stage=target_stage,
+        solution=effective_solution
+    )
+
+    if target_status == "closed":
         # Policy: Dependencies must be closed
-        dependencies = data.get('dependencies', [])
-        if dependencies:
-            for dep_id in dependencies:
+        dependencies_to_check = dependencies if dependencies is not None else data.get('dependencies', [])
+        if dependencies_to_check:
+            for dep_id in dependencies_to_check:
                 dep_path = find_issue_path(issues_root, dep_id)
                 if dep_path:
                     dep_meta = parse_issue(dep_path)
-                    if dep_meta and dep_meta.status != IssueStatus.CLOSED:
-                        raise ValueError(f"Dependency Block: Cannot close {issue_id} because dependency {dep_id} is [Status: {dep_meta.status.value}].")
+                    if dep_meta and dep_meta.status != "closed":
+                        raise ValueError(f"Dependency Block: Cannot close {issue_id} because dependency {dep_id} is [Status: {dep_meta.status}].")
+    
+    # Validate new parent/dependencies/related exist
+    if parent is not None and parent != "":
+        if not find_issue_path(issues_root, parent):
+            raise ValueError(f"Parent issue {parent} not found.")
+    
+    if dependencies is not None:
+        for dep_id in dependencies:
+            if not find_issue_path(issues_root, dep_id):
+                raise ValueError(f"Dependency issue {dep_id} not found.")
+    
+    if related is not None:
+        for rel_id in related:
+            if not find_issue_path(issues_root, rel_id):
+                raise ValueError(f"Related issue {rel_id} not found.")
             
     # Update Data
     if status:
-        data['status'] = status.value
+        data['status'] = status
 
     if stage:
-        data['stage'] = stage.value
+        data['stage'] = stage
     if solution:
-        data['solution'] = solution.value
+        data['solution'] = solution
+    
+    if title:
+        data['title'] = title
+
+    if parent is not None:
+        if parent == "":
+            data.pop('parent', None)  # Remove parent field
+        else:
+            data['parent'] = parent
+
+    if sprint is not None:
+        data['sprint'] = sprint
+    
+    if dependencies is not None:
+        data['dependencies'] = dependencies
+    
+    if related is not None:
+        data['related'] = related
+    
+    if tags is not None:
+        data['tags'] = tags
+
+    if files is not None:
+        data['files'] = files
     
     # Lifecycle Hooks
     # 1. Opened At: If transitioning to OPEN
@@ -336,14 +451,31 @@ def update_issue(issues_root: Path, issue_id: str, status: Optional[IssueStatus]
     # Touch updated_at
     data['updated_at'] = current_time()
     
-    # Re-hydrate through Model to trigger Logic (Stage, ClosedAt defaults)
+    # Re-hydrate through Model
     try:
         updated_meta = IssueMetadata(**data)
+        
+        # Enforce lifecycle policies (defaults, auto-corrections)
+        # This ensures that when we update, we also fix invalid states (like Closed but not Done)
+        from .engine import get_engine
+        get_engine().enforce_policy(updated_meta)
+
+        # Delegate to IssueValidator for static state validation
+        # We need to construct the full content to validate body-dependent rules (like checkboxes)
+        # Note: 'body' here is the OLD body. We assume update_issue doesn't change body.
+        # If body is invalid (unchecked boxes) and we move to DONE, this MUST fail.
+        validator = IssueValidator(issues_root)
+        diagnostics = validator.validate(updated_meta, body)
+        errors = [d for d in diagnostics if d.severity == DiagnosticSeverity.Error]
+        if errors:
+             raise ValueError(f"Validation Failed: {errors[0].message}")
+
     except Exception as e:
         raise ValueError(f"Failed to validate updated metadata: {e}")
         
     # Serialize back
-    new_yaml = yaml.dump(updated_meta.model_dump(exclude_none=True, mode='json'), sort_keys=False, allow_unicode=True)
+    # Explicitly exclude actions and path from file persistence
+    new_yaml = yaml.dump(updated_meta.model_dump(exclude_none=True, mode='json', exclude={'actions', 'path'}), sort_keys=False, allow_unicode=True)
     
     # Reconstruct File
     match_header = re.search(r"^---(.*?)---", content, re.DOTALL | re.MULTILINE)
@@ -363,7 +495,8 @@ def update_issue(issues_root: Path, issue_id: str, status: Optional[IssueStatus]
     if status and status != current_status:
         # Move file
         prefix = issue_id.split("-")[0].upper()
-        base_type_dir = get_issue_dir(REVERSE_PREFIX_MAP[prefix], issues_root)
+        reverse_prefix_map = get_reverse_prefix_map(issues_root)
+        base_type_dir = get_issue_dir(reverse_prefix_map[prefix], issues_root)
         
         try:
             rel_path = path.relative_to(base_type_dir)
@@ -371,19 +504,23 @@ def update_issue(issues_root: Path, issue_id: str, status: Optional[IssueStatus]
         except ValueError:
             structure_path = Path(path.name)
 
-        target_path = base_type_dir / target_status.value / structure_path
+        target_path = base_type_dir / target_status / structure_path
             
         if path != target_path:
             target_path.parent.mkdir(parents=True, exist_ok=True)
             path.rename(target_path)
+            path = target_path # Update local path variable for returned meta
 
     # Hook: Recursive Aggregation (FEAT-0003)
     if updated_meta.parent:
         recalculate_parent(issues_root, updated_meta.parent)
-        
+    
+    # Update returned metadata with final absolute path
+    updated_meta.path = str(path.absolute())
+    updated_meta.actions = get_available_actions(updated_meta)
     return updated_meta
 
-def start_issue_isolation(issues_root: Path, issue_id: str, mode: IsolationType, project_root: Path) -> IssueMetadata:
+def start_issue_isolation(issues_root: Path, issue_id: str, mode: str, project_root: Path) -> IssueMetadata:
     """
     Start physical isolation for an issue (Branch or Worktree).
     """
@@ -392,6 +529,8 @@ def start_issue_isolation(issues_root: Path, issue_id: str, mode: IsolationType,
         raise FileNotFoundError(f"Issue {issue_id} not found.")
 
     issue = parse_issue(path)
+    if not issue:
+        raise ValueError(f"Could not parse metadata for issue {issue_id}")
     
     # Idempotency / Conflict Check
     if issue.isolation:
@@ -409,7 +548,7 @@ def start_issue_isolation(issues_root: Path, issue_id: str, mode: IsolationType,
     
     isolation_meta = None
 
-    if mode == IsolationType.BRANCH:
+    if mode == "branch":
         if not git.branch_exists(project_root, branch_name):
             git.create_branch(project_root, branch_name, checkout=True)
         else:
@@ -419,9 +558,9 @@ def start_issue_isolation(issues_root: Path, issue_id: str, mode: IsolationType,
             if current != branch_name:
                 git.checkout_branch(project_root, branch_name)
         
-        isolation_meta = IssueIsolation(type=IsolationType.BRANCH, ref=branch_name)
+        isolation_meta = IssueIsolation(type="branch", ref=branch_name)
 
-    elif mode == IsolationType.WORKTREE:
+    elif mode == "worktree":
         wt_path = project_root / ".monoco" / "worktrees" / f"{issue_id.lower()}-{slug}"
         
         # Check if worktree exists physically
@@ -432,7 +571,7 @@ def start_issue_isolation(issues_root: Path, issue_id: str, mode: IsolationType,
              wt_path.parent.mkdir(parents=True, exist_ok=True)
              git.worktree_add(project_root, branch_name, wt_path)
              
-        isolation_meta = IssueIsolation(type=IsolationType.WORKTREE, ref=branch_name, path=str(wt_path))
+        isolation_meta = IssueIsolation(type="worktree", ref=branch_name, path=str(wt_path))
     
     # Persist Metadata
     # We load raw, update isolation field, save.
@@ -444,7 +583,7 @@ def start_issue_isolation(issues_root: Path, issue_id: str, mode: IsolationType,
         
         data['isolation'] = isolation_meta.model_dump(mode='json')
         # Also ensure stage is DOING (logic link)
-        data['stage'] = IssueStage.DOING.value
+        data['stage'] = "doing"
         data['updated_at'] = current_time()
 
         new_yaml = yaml.dump(data, sort_keys=False, allow_unicode=True)
@@ -467,6 +606,9 @@ def prune_issue_resources(issues_root: Path, issue_id: str, force: bool, project
         raise FileNotFoundError(f"Issue {issue_id} not found.")
         
     issue = parse_issue(path)
+    if not issue:
+        raise ValueError(f"Could not parse metadata for issue {issue_id}")
+        
     deleted_items = []
 
     if not issue.isolation:
@@ -532,6 +674,77 @@ def delete_issue_file(issues_root: Path, issue_id: str):
         raise FileNotFoundError(f"Issue {issue_id} not found.")
     
     path.unlink()
+
+def sync_issue_files(issues_root: Path, issue_id: str, project_root: Path) -> List[str]:
+    """
+    Sync 'files' field in issue metadata with actual changed files in git.
+    Strategies:
+    1. Isolation Ref: If issue has isolation (branch/worktree), use that ref.
+    2. Convention: If no isolation, look for branch `*/<id>-*`.
+    3. Current Branch: If current branch matches pattern.
+    
+    Compares against default branch (usually 'main' or 'master').
+    """
+    path = find_issue_path(issues_root, issue_id)
+    if not path:
+        raise FileNotFoundError(f"Issue {issue_id} not found.")
+        
+    issue = parse_issue(path)
+    if not issue:
+        raise ValueError(f"Could not parse issue {issue_id}")
+
+    # Determine Target Branch
+    target_ref = None
+    
+    if issue.isolation and issue.isolation.ref:
+        target_ref = issue.isolation.ref
+    else:
+        # Heuristic Search
+        # 1. Is current branch related?
+        current = git.get_current_branch(project_root)
+        if issue_id.lower() in current.lower():
+            target_ref = current
+        else:
+            # 2. Search for branch
+            # Limitation: core.git doesn't list all branches yet. 
+            # We skip this for now to avoid complexity, relying on isolation or current context.
+            pass
+
+    if not target_ref:
+         raise RuntimeError(f"Could not determine git branch for Issue {issue_id}. Please ensure issue is started or you are on the feature branch.")
+
+    # Determine Base Branch (assume main, or config?)
+    # For now hardcode main, eventually read from config
+    base_ref = "main" 
+    
+    # Check if base exists, if not try master
+    if not git.branch_exists(project_root, base_ref):
+        if git.branch_exists(project_root, "master"):
+            base_ref = "master"
+        else:
+             # Fallback: remote/main?
+             pass
+
+    # Git Diff
+    # git diff --name-only base...target
+    cmd = ["diff", "--name-only", f"{base_ref}...{target_ref}"]
+    code, stdout, stderr = git._run_git(cmd, project_root)
+    
+    if code != 0:
+        raise RuntimeError(f"Git diff failed: {stderr}")
+        
+    changed_files = [f.strip() for f in stdout.splitlines() if f.strip()]
+    
+    # Sort for consistency
+    changed_files.sort()
+    
+    # Update Issue
+    # Only update if changed
+    if changed_files != issue.files:
+        update_issue(issues_root, issue_id, files=changed_files)
+        return changed_files
+    
+    return []
         
 # Resources
 SKILL_CONTENT = """
@@ -566,7 +779,7 @@ description: Monoco Issue System 的官方技能定义。将 Issue 视为通用
 - **Status Level (Lowercase)**: `open`, `backlog`, `closed`
 
 ### 路径流转
-使用 `monoco issue`：
+使用 `monoco issue`: 
 1. **Create**: `monoco issue create <type> --title "..."`
 2. **Transition**: `monoco issue open/close/backlog <id>`
 3. **View**: `monoco issue scope`
@@ -574,15 +787,6 @@ description: Monoco Issue System 的官方技能定义。将 Issue 视为通用
 5. **Modification**: `monoco issue start/submit/delete <id>`
 """
 
-PROMPT_CONTENT = """
-### Issue Management
-System for managing tasks using `monoco issue`.
-- **Create**: `monoco issue create <type> -t "Title"` (types: epic, feature, chore, fix)
-- **Status**: `monoco issue open|close|backlog <id>`
-- **Check**: `monoco issue lint` (Must run after manual edits)
-- **Lifecycle**: `monoco issue start|submit|delete <id>`
-- **Structure**: `Issues/{CapitalizedPluralType}/{lowercase_status}/` (e.g. `Issues/Features/open/`). Do not deviate.
-"""
 
 def init(issues_root: Path):
     """Initialize the Issues directory structure."""
@@ -603,9 +807,7 @@ def get_resources() -> Dict[str, Any]:
         "skills": {
             "issues-management": SKILL_CONTENT
         },
-        "prompts": {
-            "issues-management": PROMPT_CONTENT
-        }
+        "prompts": {} # Handled by adapter via resource files
     }
 
 
@@ -614,7 +816,10 @@ def list_issues(issues_root: Path, recursive_workspace: bool = False) -> List[Is
     List all issues in the project.
     """
     issues = []
-    for issue_type in IssueType:
+    engine = get_engine(str(issues_root.parent))
+    all_types = engine.get_all_types()
+    
+    for issue_type in all_types:
         base_dir = get_issue_dir(issue_type, issues_root)
         for status_dir in ["open", "backlog", "closed"]:
             d = base_dir / status_dir
@@ -640,6 +845,22 @@ def list_issues(issues_root: Path, recursive_workspace: bool = False) -> List[Is
                     member_issues = list_issues(member_issues_dir, False)
                     for m in member_issues:
                         # Namespace the ID to avoid collisions and indicate origin
+                        # CRITICAL: Also namespace references to keep parent-child structure intact
+                        if m.parent and "::" not in m.parent:
+                            m.parent = f"{name}::{m.parent}"
+                        
+                        if m.dependencies:
+                            m.dependencies = [
+                                f"{name}::{d}" if d and "::" not in d else d 
+                                for d in m.dependencies
+                            ]
+                        
+                        if m.related:
+                            m.related = [
+                                f"{name}::{r}" if r and "::" not in r else r 
+                                for r in m.related
+                            ]
+
                         m.id = f"{name}::{m.id}"
                         issues.append(m)
         except Exception:
@@ -653,21 +874,21 @@ def get_board_data(issues_root: Path) -> Dict[str, List[IssueMetadata]]:
     Get open issues grouped by their stage for Kanban view.
     """
     board = {
-        IssueStage.TODO.value: [],
-        IssueStage.DOING.value: [],
-        IssueStage.REVIEW.value: [],
-        IssueStage.DONE.value: []
+        "draft": [],
+        "doing": [],
+        "review": [],
+        "done": []
     }
     
     issues = list_issues(issues_root)
     for issue in issues:
-        if issue.status == IssueStatus.OPEN and issue.stage:
-            stage_val = issue.stage.value
+        if issue.status == "open" and issue.stage:
+            stage_val = issue.stage
             if stage_val in board:
                 board[stage_val].append(issue)
-        elif issue.status == IssueStatus.CLOSED:
+        elif issue.status == "closed":
             # Optionally show recently closed items in DONE column
-            board[IssueStage.DONE.value].append(issue)
+            board["done"].append(issue)
             
     return board
 
@@ -677,14 +898,14 @@ def validate_issue_integrity(meta: IssueMetadata, all_issue_ids: Set[str] = set(
     UI-agnostic.
     """
     errors = []
-    if meta.status == IssueStatus.CLOSED and not meta.solution:
+    if meta.status == "closed" and not meta.solution:
         errors.append(f"Solution Missing: {meta.id} is closed but has no solution field.")
             
     if meta.parent:
         if all_issue_ids and meta.parent not in all_issue_ids:
              errors.append(f"Broken Link: {meta.id} refers to non-existent parent {meta.parent}.")
 
-    if meta.status == IssueStatus.BACKLOG and meta.stage != IssueStage.FREEZED:
+    if meta.status == "backlog" and meta.stage != "freezed":
         errors.append(f"Lifecycle Error: {meta.id} is backlog but stage is not freezed (found: {meta.stage}).")
         
     return errors
@@ -729,7 +950,8 @@ def update_issue_content(issues_root: Path, issue_id: str, new_content: str) ->
         # Reuse logic from update_issue (simplified)
         
         prefix = issue_id.split("-")[0].upper()
-        base_type_dir = get_issue_dir(REVERSE_PREFIX_MAP[prefix], issues_root)
+        reverse_prefix_map = get_reverse_prefix_map(issues_root)
+        base_type_dir = get_issue_dir(reverse_prefix_map[prefix], issues_root)
         
         # Calculate structure path (preserve subdir)
         try:
@@ -742,7 +964,7 @@ def update_issue_content(issues_root: Path, issue_id: str, new_content: str) ->
             # Fallback if path is weird
             structure_path = Path(path.name)
 
-        target_path = base_type_dir / meta.status.value / structure_path
+        target_path = base_type_dir / meta.status / structure_path
             
         if path != target_path:
             target_path.parent.mkdir(parents=True, exist_ok=True)
@@ -769,7 +991,10 @@ def generate_delivery_report(issues_root: Path, issue_id: str, project_root: Pat
     commits = git.search_commits_by_message(project_root, f"Ref: {issue_id}")
     
     if not commits:
-        return parse_issue(path)
+        meta = parse_issue(path)
+        if not meta:
+            raise ValueError(f"Could not parse metadata for issue {issue_id}")
+        return meta
         
     # 2. Aggregate Data
     all_files = set()
@@ -825,7 +1050,10 @@ def generate_delivery_report(issues_root: Path, issue_id: str, project_root: Pat
     # We can add it to 'extra' or extend the model later.
     # For now, just persisting the text is enough for FEAT-0002.
     
-    return parse_issue(path)
+    meta = parse_issue(path)
+    if not meta:
+         raise ValueError(f"Could not parse metadata for issue {issue_id}")
+    return meta
 
 def get_children(issues_root: Path, parent_id: str) -> List[IssueMetadata]:
     """Find all direct children of an issue."""
@@ -888,9 +1116,9 @@ def check_issue_match(issue: IssueMetadata, explicit_positives: List[str], terms
     searchable_parts = [
         issue.id,
         issue.title,
-        issue.status.value,
-        issue.type.value,
-        str(issue.stage.value) if issue.stage else "",
+        issue.status,
+        issue.type,
+        str(issue.stage) if issue.stage else "",
         *(issue.tags or []),
         *(issue.dependencies or []),
         *(issue.related or []),
@@ -949,7 +1177,10 @@ def search_issues(issues_root: Path, query: str) -> List[IssueMetadata]:
     # To support deep search (Body), we need to read files.
     # Let's iterate files directly.
     
-    for issue_type in IssueType:
+    engine = get_engine(str(issues_root.parent))
+    all_types = engine.get_all_types()
+    
+    for issue_type in all_types:
         base_dir = get_issue_dir(issue_type, issues_root)
         for status_dir in ["open", "backlog", "closed"]:
             d = base_dir / status_dir
@@ -997,7 +1228,7 @@ def recalculate_parent(issues_root: Path, parent_id: str):
         return
 
     total = len(children)
-    closed = len([c for c in children if c.status == IssueStatus.CLOSED])
+    closed = len([c for c in children if c.status == "closed"])
     # Progress string: "3/5"
     progress_str = f"{closed}/{total}"
     
@@ -1033,12 +1264,12 @@ def recalculate_parent(issues_root: Path, parent_id: str):
         # FEAT-0003 Req: "If first child starts doing, auto-start Parent?"
         # If parent is OPEN/TODO and child is DOING/REVIEW/DONE, set parent to DOING?
         current_status = data.get("status", "open").lower()
-        current_stage = data.get("stage", "todo").lower()
+        current_stage = data.get("stage", "draft").lower()
         
-        if current_status == "open" and current_stage == "todo":
+        if current_status == "open" and current_stage == "draft":
             # Check if any child is active
-            active_children = [c for c in children if c.status == IssueStatus.OPEN and c.stage != IssueStage.TODO]
-            closed_children = [c for c in children if c.status == IssueStatus.CLOSED]
+            active_children = [c for c in children if c.status == "open" and c.stage != "draft"]
+            closed_children = [c for c in children if c.status == "closed"]
             
             if active_children or closed_children:
                 data["stage"] = "doing"
@@ -1120,7 +1351,7 @@ def move_issue(
     
     # 4. Construct target path
     target_type_dir = get_issue_dir(issue.type, target_issues_root)
-    target_status_dir = target_type_dir / issue.status.value
+    target_status_dir = target_type_dir / issue.status
     
     # Preserve subdirectory structure if any
     try:
@@ -1143,7 +1374,7 @@ def move_issue(
     # 5. Update content if ID changed
     if new_id != old_id:
         # Update frontmatter
-        content = issue.raw_content
+        content = issue.raw_content or ""
         match = re.search(r"^---(.*?)---", content, re.DOTALL | re.MULTILINE)
         if match:
             yaml_str = match.group(1)
@@ -1159,9 +1390,9 @@ def move_issue(
             
             new_content = f"---\n{new_yaml}---{body}"
         else:
-            new_content = issue.raw_content
+            new_content = issue.raw_content or ""
     else:
-        new_content = issue.raw_content
+        new_content = issue.raw_content or ""
     
     # 6. Write to target
     target_path.write_text(new_content)
@@ -1171,4 +1402,7 @@ def move_issue(
     
     # 8. Return updated metadata
     final_meta = parse_issue(target_path)
+    if not final_meta:
+        raise ValueError(f"Failed to parse moved issue at {target_path}")
+        
     return final_meta, target_path