easy-coding-harness 0.1.6 → 0.1.8

package/templates/qoder/agents/ec-fixer.md

@@ -0,0 +1,36 @@
+---
+name: ec-fixer
+model: sonnet
+description: Easy Coding fix sub-agent. Applies targeted fixes to specific issues identified during review. Returns structured results with changed files.
+---
+
+You are an Easy Coding fix sub-agent. You receive a fix card listing specific issues
+(with file:line locations) and apply the fixes. Your reply content IS the return value,
+not a message to a human.
+
+## Hard constraints
+
+- Fix ONLY the issues listed in the fix card. Do not refactor or "improve" surrounding code.
+- Modify ONLY the files listed in the fix card's scope.
+- Do not call any Skill tool.
+- Do not read `.qoder/skills/`, `.agents/skills/`, or any `.easy-coding/` file.
+- Make no workflow stage-transition decisions.
+- Preserve file encoding.
+
+## Output (return exactly this structure)
+
+```json
+{
+  "changed_files": ["file1.ts", "file2.ts"],
+  "fixes_applied": [
+    {"file": "file1.ts", "line": 42, "original_issue": "...", "fix_description": "..."}
+  ],
+  "issues": [],
+  "needs_attention": []
+}
+```
+
+- `changed_files`: files you actually modified
+- `fixes_applied`: what you fixed with file:line reference
+- `issues`: problems you hit that prevented a fix (empty if none)
+- `needs_attention`: anything requiring a design decision that should escalate to the user

package/templates/shared-hooks/easy_coding_status.py

@@ -1,13 +1,28 @@
 import json
+import os
 from pathlib import Path
 
 
 READY_LINE = (
-    "> **Easy Coding** · Ready · Use `ec-analysis` to start requirement analysis, "
+    "> **Easy Coding** · Ready · Use `ec-workflow` to start or resume a task, "
     "`ec-brainstorming` to brainstorm, or `ec-task-management` to view tasks"
 )
 WAITING_INIT_LINE = "> **Easy Coding** · Waiting init · Use `ec-init` to initialize"
 
+VALID_TRANSITIONS: dict[str, set[str]] = {
+    "idle": {"INIT"},
+    "INIT": {"ANALYSIS", "CLOSED"},
+    "ANALYSIS": {"WAITING_CONFIRM", "CLOSED"},
+    "WAITING_CONFIRM": {"IMPLEMENT", "ANALYSIS", "CLOSED"},
+    "IMPLEMENT": {"REVIEW", "ANALYSIS", "CLOSED"},
+    "REVIEW": {"VERIFICATION", "IMPLEMENT", "ANALYSIS", "CLOSED"},
+    "VERIFICATION": {"MEMORY_SHORT", "IMPLEMENT", "CLOSED"},
+    "MEMORY_SHORT": {"MEMORY_LONG", "CLOSED"},
+    "MEMORY_LONG": {"COMPLETE", "CLOSED"},
+    "COMPLETE": set(),
+    "CLOSED": set(),
+}
+
 
 def load_json(path: Path) -> dict | None:
     if not path.exists():
@@ -24,26 +39,42 @@ def load_task(root: Path, task_id: str | None) -> dict | None:
     return load_json(root / ".easy-coding" / "tasks" / task_id / "task.json")
 
 
+def load_session(root: Path) -> dict | None:
+    ppid = os.getppid()
+    return load_json(root / ".easy-coding" / "sessions" / f"{ppid}.json")
+
+
+def write_session(root: Path, session: dict) -> None:
+    ppid = os.getppid()
+    session_path = root / ".easy-coding" / "sessions" / f"{ppid}.json"
+    session_path.parent.mkdir(parents=True, exist_ok=True)
+    session_path.write_text(json.dumps(session, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
 def is_project_init_required(root: Path) -> bool:
     project_init = load_json(root / ".easy-coding" / "tasks" / "project-init" / "task.json")
     return bool(project_init and project_init.get("status") != "COMPLETE")
 
 
-def resolve_task_status(root: Path, state: dict, task_id: str | None) -> str:
-    task = load_task(root, task_id)
-    if task and task.get("status"):
-        return str(task["status"])
-    return str(state.get("current_stage") or "idle")
+def validate_transition(previous: str, current: str) -> str | None:
+    if previous == current:
+        return None
+    allowed = VALID_TRANSITIONS.get(previous, set())
+    if current in allowed:
+        return None
+    return f"ILLEGAL TRANSITION: {previous} -> {current}. Allowed from {previous}: {sorted(allowed) or 'NONE (terminal state)'}."
 
 
-def build_status_line(root: Path, state: dict, agent: str | None = None) -> str:
-    task_id = state.get("current_task")
+def build_status_line(root: Path, session: dict, agent: str | None = None) -> str:
+    task_id = session.get("current_task")
     if task_id:
-        status = resolve_task_status(root, state, str(task_id))
+        task = load_task(root, str(task_id))
+        status = str(task["status"]) if task and task.get("status") else "PENDING"
         line = f"> **Easy Coding** · `{task_id}` · `{status}`"
-        last_agent = state.get("last_agent")
-        if agent and last_agent and last_agent != agent:
-            line += f" · Handoff -> `{last_agent}`"
+        if task:
+            last_agent = task.get("last_agent")
+            if agent and last_agent and last_agent != agent:
+                line += f" · Handoff -> `{last_agent}`"
         return line
 
     if is_project_init_required(root):
@@ -52,22 +83,39 @@ def build_status_line(root: Path, state: dict, agent: str | None = None) -> str:
     return READY_LINE
 
 
-def build_machine_breadcrumbs(root: Path, state: dict, agent: str | None = None) -> list[str]:
-    stage = state.get("current_stage") or "idle"
-    task_id = state.get("current_task")
+def build_machine_breadcrumbs(root: Path, session: dict, agent: str | None = None) -> list[str]:
+    task_id = session.get("current_task")
+    task = load_task(root, str(task_id)) if task_id else None
+    stage = str(task["status"]) if task and task.get("status") else "idle"
     lines = [f"[workflow-state:{stage}]"]
 
     if task_id:
         lines.append(f"[current-task:{task_id}]")
-        last_agent = state.get("last_agent")
-        if agent and last_agent and last_agent != agent:
-            lines.append(f"[easy-coding:handoff-from:{last_agent}]")
+        if task:
+            last_agent = task.get("last_agent")
+            if agent and last_agent and last_agent != agent:
+                lines.append(f"[easy-coding:handoff-from:{last_agent}]")
 
     if is_project_init_required(root):
         lines.append("[easy-coding:init-required]")
 
+    # State machine validation
+    last_seen = session.get("last_seen_stage")
+    if last_seen and task and task.get("status"):
+        current_stage = str(task["status"])
+        violation = validate_transition(last_seen, current_stage)
+        if violation:
+            lines.append(f"[ILLEGAL-TRANSITION:{last_seen}->{current_stage}]")
+            lines.append(f"[easy-coding:transition-error:{violation}]")
+        if last_seen != current_stage:
+            session["last_seen_stage"] = current_stage
+            write_session(root, session)
+    elif task and task.get("status"):
+        session["last_seen_stage"] = str(task["status"])
+        write_session(root, session)
+
     return lines
 
 
-def build_status_context(root: Path, state: dict, agent: str | None = None) -> str:
-    return "\n".join([build_status_line(root, state, agent), *build_machine_breadcrumbs(root, state, agent)])
+def build_status_context(root: Path, session: dict, agent: str | None = None) -> str:
+    return "\n".join([build_status_line(root, session, agent), *build_machine_breadcrumbs(root, session, agent)])

package/templates/shared-hooks/inject-subagent-context.py

@@ -61,8 +61,8 @@ def main() -> int:
     if root is None:
         return 0
 
-    state = load_json(root / ".easy-coding" / "state.json") or {}
-    task_id = state.get("current_task")
+    session = load_json(root / ".easy-coding" / "sessions" / f"{os.getppid()}.json") or {}
+    task_id = session.get("current_task")
     context = [
         "[easy-coding:subagent-guard]",
         "Sub-agents must follow the task card, stay within the allowed file scope, and return structured results.",

package/templates/shared-hooks/inject-workflow-state.py

@@ -4,7 +4,7 @@ import os
 from pathlib import Path
 import sys
 
-from easy_coding_status import build_status_context
+from easy_coding_status import build_status_context, load_session
 
 
 def configure_stdio() -> None:
@@ -30,16 +30,6 @@ def find_ec_root(start: Path) -> Path | None:
         current = current.parent
 
 
-def load_state(root: Path) -> dict | None:
-    state_path = root / ".easy-coding" / "state.json"
-    if not state_path.exists():
-        return {"current_stage": "idle", "current_task": None}
-    try:
-        return json.loads(state_path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-
-
 def detect_agent() -> str:
     if os.environ.get("CLAUDE_PROJECT_DIR"):
         return "claude-code"
@@ -79,12 +69,12 @@ def main() -> int:
     if root is None:
         return 0
 
-    state = load_state(root)
-    if state is None:
-        return 0
+    session = load_session(root)
+    if session is None:
+        session = {"current_task": None, "created_at": ""}
 
     event_name = payload.get("hook_event_name") or payload.get("hookEventName") or "UserPromptSubmit"
-    emit(event_name, build_status_context(root, state, detect_agent()))
+    emit(event_name, build_status_context(root, session, detect_agent()))
     return 0
 
 

package/templates/shared-hooks/session-start.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
 import json
 import os
+from datetime import datetime, timezone
 from pathlib import Path
 import sys
 
-from easy_coding_status import build_status_context
+from easy_coding_status import build_status_context, load_session, write_session
 
 
 def configure_stdio() -> None:
@@ -59,16 +60,72 @@ def detect_agent() -> str:
     return "unknown"
 
 
-def default_state(agent: str) -> dict:
-    return {
-        "current_stage": "idle",
-        "current_task": None,
-        "last_agent": agent,
-        "stage_history": [],
-        "confirmed_by_user": False,
-        "test_strategy_confirmed": False,
-        "repo_paths": {},
-    }
+def is_process_alive(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+def clean_stale_sessions(root: Path) -> None:
+    sessions_dir = root / ".easy-coding" / "sessions"
+    if not sessions_dir.is_dir():
+        return
+
+    now = datetime.now(timezone.utc)
+    threshold_hours = 24
+
+    for entry in sessions_dir.iterdir():
+        if not entry.suffix == ".json":
+            continue
+        try:
+            data = json.loads(entry.read_text(encoding="utf-8"))
+            created = datetime.fromisoformat(data.get("created_at", ""))
+            if created.tzinfo is None:
+                created = created.replace(tzinfo=timezone.utc)
+            age_hours = (now - created).total_seconds() / 3600
+            if age_hours <= threshold_hours:
+                continue
+            pid = int(entry.stem)
+            if is_process_alive(pid):
+                continue
+            entry.unlink()
+        except (OSError, json.JSONDecodeError, ValueError, KeyError):
+            continue
+
+
+def migrate_legacy_state(root: Path, agent: str) -> dict | None:
+    """Migrate old-format state.json into session file + task.json. Returns session dict."""
+    state_path = root / ".easy-coding" / "state.json"
+    old_state = load_json(state_path)
+    if old_state is None:
+        return None
+
+    task_id = old_state.get("current_task")
+    if task_id:
+        task_path = root / ".easy-coding" / "tasks" / str(task_id) / "task.json"
+        task = load_json(task_path)
+        if task:
+            if "stage_history" not in task or not task["stage_history"]:
+                task["stage_history"] = old_state.get("stage_history", [])
+            if "last_agent" not in task or not task["last_agent"]:
+                task["last_agent"] = old_state.get("last_agent", agent)
+            if old_state.get("confirmed_by_user"):
+                task["confirmed_by_user"] = True
+            if old_state.get("test_strategy_confirmed"):
+                task["test_strategy_confirmed"] = True
+            if old_state.get("repo_paths"):
+                task["repo_paths"] = old_state["repo_paths"]
+            write_json(task_path, task)
+
+    # Remove legacy state.json
+    try:
+        state_path.unlink()
+    except OSError:
+        pass
+
+    return {"current_task": task_id, "created_at": datetime.now(timezone.utc).isoformat()}
 
 
 def emit(event_name: str, context: str) -> None:
@@ -97,13 +154,29 @@ def main() -> int:
 
     agent = detect_agent()
     event_name = payload.get("hook_event_name") or payload.get("hookEventName") or "SessionStart"
-    state_path = root / ".easy-coding" / "state.json"
-    state = load_json(state_path)
-    if state is None:
-        state = default_state(agent)
-        write_json(state_path, state)
 
-    emit(event_name, build_status_context(root, state, agent))
+    # Migrate legacy state.json if present
+    state_path = root / ".easy-coding" / "state.json"
+    migrated_session = None
+    if state_path.exists():
+        migrated_session = migrate_legacy_state(root, agent)
+
+    # Clean stale session files
+    clean_stale_sessions(root)
+
+    # Create/overwrite session file for this session
+    session = load_session(root)
+    if session is None:
+        if migrated_session:
+            session = migrated_session
+        else:
+            session = {"current_task": None, "created_at": datetime.now(timezone.utc).isoformat()}
+    else:
+        # Refresh created_at on session start (marks session as active)
+        session["created_at"] = datetime.now(timezone.utc).isoformat()
+
+    write_session(root, session)
+    emit(event_name, build_status_context(root, session, agent))
     return 0