easy-coding-harness 0.3.2 → 0.3.3

package/CHANGELOG.md

@@ -6,6 +6,13 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.3.3
+
+- 修复同一轮会话内状态栏仍显示旧状态的问题：`easy_coding_state.py` 的所有写状态命令现在都会在写入后立即回读 session/task，并返回最新 `status_line` 和 `status_context`。
+- `create-task`、`set-current`、`clear-current`、`transition`、`close-current`、`project-init-complete`、`set-repo-path` 输出统一携带最新状态上下文，覆盖新建任务、切换任务、阶段迁移、关闭任务和初始化完成等所有状态写路径。
+- 状态渲染逻辑收口到 state API，`easy_coding_status.py` 仅保留兼容导出，避免 hook 渲染和 state API 回读逻辑再次漂移。
+- skill 模板强化规则：任何状态写入命令返回后，必须使用返回的 `status_context` 作为当前轮的权威状态来源，丢弃旧的 hook 注入状态。
+
 ## 0.3.2
 
 - npm 包元数据切换到 GitHub：`repository`、`homepage` 和 `bugs.url` 均指向 `github.com/ysxiiun/easy-coding-harness`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easy-coding-harness",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "CLI scaffold for installing Easy Coding harness files into agent-native directories.",
   "repository": {
     "type": "git",

package/templates/common/bundled-skills/ec-init/SKILL.md

@@ -82,7 +82,8 @@ On decline: exit with the gap list as a reference for the user to address manual
 gaps were fixed), run
 `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py project-init-complete --agent <agent-id>`.
 This removes `pending_init_since` and clears the "Waiting init · Upgrade" status line so the
-user is no longer prompted on every session.
+user is no longer prompted on every session. Use the returned `status_context` as the current
+status source.
 
 ## Project mode detection (automatic — never ask the user)
 
@@ -138,7 +139,8 @@ agent must be able to see what was generated and on what evidence.
    fake entries.
 7. **Mark complete** — write the final `init_log` entry, then run
    `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py project-init-complete --agent <agent-id>`.
-   Tell the user initialization is done and daily work goes through `{{skill_trigger}}ec-workflow`.
+   Use the returned `status_context`, then tell the user initialization is done and daily work
+   goes through `{{skill_trigger}}ec-workflow`.
 
 ## Startup project flow
 

package/templates/common/skills/ec-analysis/SKILL.md

@@ -72,6 +72,7 @@ If the task spans repositories: declare them in the dev-spec (trigger repo + inv
 by **name**, never local paths). For each involved repo, read its ABSTRACT to understand the
 interface. Cache any local path the user provides through the state API only:
 `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py set-repo-path --session-file <P> --repo <repo-name> --path <local-path>`.
+Use the returned `status_context` as the latest state source after this write.
 If a repo name cannot be located locally, ask the user for the path before proceeding.
 
 ## Analysis procedure (mandatory sequence)

package/templates/common/skills/ec-task-close/SKILL.md

@@ -22,6 +22,8 @@ when you recognize abandonment intent in the user's message.
    `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py close-current --session-file <P> --reason "<reason>" --agent <agent-id>`.
    This sets `task.json.status` to `CLOSED`, records `closed_reason`, updates history, and
    clears session `current_task` so the next hook injection returns to Ready.
+   Use the returned `status_context` as the authoritative status source for the rest of the
+   current turn.
 4. **No memory flow.** Do not run MEMORY_SHORT/LONG. An incomplete task's memory is dirty data.
 5. **Linked tasks.** If the task has `spawned_from` or `spawned_tasks`, note the closure fact
    on the relation so a future agent understands the chain.

package/templates/common/skills/ec-task-management/SKILL.md

@@ -25,6 +25,10 @@ If the user explicitly wants to start the task now, omit `--no-set-current`; oth
 the current workflow pointer untouched and tell them to run `{{skill_trigger}}ec-workflow`
 when ready.
 
+The command returns `status_line` and `status_context`. If the command sets or changes
+`current_task`, use the returned context as the authoritative status source for the rest of
+the current turn instead of older hook-injected status text.
+
 ## Boundaries
 
 - No workflow recovery — point the user to ec-workflow to resume or progress a task.

package/templates/common/skills/ec-verification/SKILL.md

@@ -77,13 +77,16 @@ change formally returns to IMPLEMENT and re-walks REVIEW → VERIFICATION.
 Runs automatically once the user accepts:
 1. MEMORY_SHORT — call
    `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py transition --session-file <P> --stage MEMORY_SHORT --agent <agent-id>`,
-   then hand control to ec-memory to write the short memory entry.
+   use the returned `status_context` as the latest status source, then hand control to
+   ec-memory to write the short memory entry.
 2. MEMORY_LONG — after MEMORY_SHORT returns, call
    `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py transition --session-file <P> --stage MEMORY_LONG --agent <agent-id>`,
-   then hand control to ec-memory to distill long memory or perform its no-op gate.
+   use the returned `status_context` and `memory_long` object as authoritative, then hand
+   control to ec-memory to distill long memory or perform its no-op gate.
 3. COMPLETE — after MEMORY_LONG returns, call
    `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py transition --session-file <P> --stage COMPLETE --agent <agent-id>`,
-   which clears session `current_task` for the completed task. Then output the task summary
-   (what was done, files changed, key decisions).
+   which clears session `current_task` for the completed task. Use the returned
+   `status_context`, then output the task summary (what was done, files changed, key
+   decisions).
 
 Hand control back to ec-workflow at each transition; ec-workflow owns the stage writes.

package/templates/common/skills/ec-workflow/SKILL.md

@@ -61,7 +61,7 @@ replies are English.
    the task through the state API, which creates `task.json`, sets `status:"INIT"`, writes
    `stage_history`, and sets the session `current_task`:
    `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py create-task --session-file <P> --task-id <MM-DD-task-slug> --type <type> --title "<one-line summary>" --agent <agent-id>`.
-   Then enter INIT.
+   Use the returned `status_context` as the current status source. Then enter INIT.
 
 ## State machine
 
@@ -100,7 +100,8 @@ When the user confirms switching from task A to task B:
 1. Task A's status is already persisted in its `task.json` — nothing extra to save.
 2. Set the current task through the state API:
    `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py set-current --session-file <P> --task-id <task-b-id> --agent <agent-id>`.
-3. Read task B's `task.json` to determine its current stage.
+3. Use the returned `status_context` as the current status source, then read task B's
+   `task.json` to determine its current stage.
 4. Resume task B's stage via the appropriate stage skill.
 
 No data is lost — task A's dev-spec, execution.jsonl, and test-strategy.md stay intact on
@@ -140,6 +141,9 @@ routing matches, and switching happens again.
 - **On every transition** call the state API immediately (not at turn end):
   `{{PYTHON_CMD}} {{platform_config_dir}}/hooks/easy_coding_state.py transition --session-file <P> --stage <STAGE> --agent <agent-id>`.
   Do not hand-edit `status`, `stage_history`, `last_agent`, `current_task`, or session files.
+  The command returns `status_line` and `status_context`; after any state-changing command,
+  discard older hook-injected status text and use this returned context as the authoritative
+  status source for the rest of the current turn.
   If the target stage is already present because a hook preflight completed it, do not issue a
   duplicate transition; use the latest snapshot and continue with the target stage's action.
 - **Hook enforcement.** The `inject-workflow-state` hook validates every stage transition
@@ -160,6 +164,8 @@ routing matches, and switching happens again.
   For each archive step, transition first and run the corresponding action second:
   after MEMORY_SHORT is persisted, write the short memory; after MEMORY_LONG is persisted,
   handle the `memory_long` instruction; after COMPLETE is persisted, produce the final summary.
+  At each transition, use the state API's returned `status_context` as the latest status
+  source before running the next action.
   When transitioning to MEMORY_LONG, pass the state API snapshot to ec-memory and treat its
   `memory_long` object as authoritative: `action == "no-op"` advances to COMPLETE without
   reading or writing long memory; `action == "distill"` runs distillation for `trim_count`

package/templates/shared-hooks/easy_coding_state.py

@@ -12,6 +12,27 @@ HELP_SUFFIX = (
     "Use `ec-workflow` to start or resume a task, "
     "`ec-brainstorming` to brainstorm, or `ec-task-management` to view tasks"
 )
+READY_LINE = (
+    "> **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"
+
+MANDATORY_DEV_SPEC_HEADERS: list[str] = [
+    "## 技术方案",
+    "### 项目模式",
+    "### 任务类型",
+    "### 需求解析",
+    "### 现状",
+    "### 冲突摘要",
+    "### 待用户决策",
+    "### 影响面分析",
+    "### 改动范围",
+    "### 修改方案",
+    "### 实施拆解",
+    "### 测试策略",
+    "### 风险与注意事项",
+]
 
 VALID_TRANSITIONS: dict[str, set[str]] = {
     "idle": {"INIT"},
@@ -291,6 +312,126 @@ def snapshot_state(
     }
 
 
+def build_status_line(
+    root: Path,
+    session: dict,
+    agent: str | None = None,
+    session_file: str | Path | None = None,
+) -> str:
+    state = snapshot_state(root, session_file, session)
+    task_id = state["current_task"]
+    if task_id:
+        status = str(state["status"])
+        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 state["is_terminal"] or state["task_missing"]:
+            line += f" · {HELP_SUFFIX}"
+        return line
+
+    if is_project_init_required(root):
+        return WAITING_INIT_LINE
+
+    pending = get_pending_init_version(root)
+    if pending:
+        return (
+            f"> **Easy Coding** · Waiting init · "
+            f"Upgrade to v{pending} — run `ec-init` to adapt"
+        )
+
+    return READY_LINE
+
+
+def build_machine_breadcrumbs(
+    root: Path,
+    session: dict,
+    agent: str | None = None,
+    session_file: str | Path | None = None,
+) -> list[str]:
+    state = snapshot_state(root, session_file, session)
+    task_id = state["current_task"]
+    task = state["task"]
+    stage = str(state["status"]) if task else "idle"
+    resolved_session_file = str(state["session_file"])
+    lines = [f"[workflow-state:{stage}]", f"[easy-coding:session-file:{resolved_session_file}]"]
+
+    if task_id:
+        lines.append(f"[current-task:{task_id}]")
+        if state["task_missing"]:
+            lines.append(f"[easy-coding:current-task-missing:{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 is_project_init_required(root):
+        lines.append("[easy-coding:init-required]")
+    else:
+        pending = get_pending_init_version(root)
+        if pending:
+            lines.append(f"[easy-coding:upgrade-init-pending:{pending}]")
+
+    # Stage-specific reminders
+    if stage == "ANALYSIS" and task_id:
+        dev_spec = root / ".easy-coding" / "tasks" / str(task_id) / "dev-spec.md"
+        if dev_spec.exists():
+            try:
+                content = dev_spec.read_text(encoding="utf-8")
+                missing = [h for h in MANDATORY_DEV_SPEC_HEADERS if h not in content]
+                if missing:
+                    names = ",".join(h.lstrip("#").strip() for h in missing)
+                    lines.append(f"[easy-coding:analysis-template-drift:missing:{names}]")
+                else:
+                    lines.append("[easy-coding:analysis-template-ok]")
+            except OSError:
+                lines.append("[easy-coding:analysis-gate:skeleton-first-then-fill]")
+        else:
+            lines.append("[easy-coding:analysis-gate:skeleton-first-then-fill]")
+
+    # State machine validation
+    if task_id and task and task.get("status"):
+        current_stage = str(task["status"])
+        last_seen = session.get("last_seen_stage")
+        violation = record_seen_stage(root, str(task_id), current_stage, resolved_session_file)
+        if violation:
+            lines.append(f"[ILLEGAL-TRANSITION:{last_seen}->{current_stage}]")
+            lines.append(f"[easy-coding:transition-error:{violation}]")
+
+    return lines
+
+
+def build_status_context(
+    root: Path,
+    session: dict,
+    agent: str | None = None,
+    session_file: str | Path | None = None,
+) -> str:
+    return "\n".join(
+        [
+            build_status_line(root, session, agent, session_file),
+            *build_machine_breadcrumbs(root, session, agent, session_file),
+        ]
+    )
+
+
+def attach_status_context(
+    root: Path,
+    data: dict,
+    agent: str | None = None,
+    session_file: str | Path | None = None,
+) -> dict:
+    resolved_session_file = session_file or data.get("session_file")
+    session = load_session(root, resolved_session_file)
+    if session is None:
+        session = default_session()
+    context = build_status_context(root, session, agent, resolved_session_file)
+    first_line = context.splitlines()[0] if context else ""
+    enriched = dict(data)
+    enriched["status_line"] = first_line
+    enriched["status_context"] = context
+    return enriched
+
+
 def list_tasks(root: Path) -> list[dict]:
     tasks_dir = root / ".easy-coding" / "tasks"
     if not tasks_dir.is_dir():
@@ -578,28 +719,75 @@ def main() -> int:
             emit({"tasks": list_tasks(root)})
         elif command == "create-task":
             emit(
-                create_task(
+                attach_status_context(
                     root,
-                    args.task_id,
-                    args.type,
-                    args.title,
+                    create_task(
+                        root,
+                        args.task_id,
+                        args.type,
+                        args.title,
+                        args.agent,
+                        not args.no_set_current,
+                        session_file,
+                    ),
                     args.agent,
-                    not args.no_set_current,
                     session_file,
                 )
             )
         elif command == "set-current":
-            emit(set_current_task(root, args.task_id, args.agent, session_file))
+            emit(
+                attach_status_context(
+                    root,
+                    set_current_task(root, args.task_id, args.agent, session_file),
+                    args.agent,
+                    session_file,
+                )
+            )
         elif command == "clear-current":
-            emit(clear_current_task(root, args.agent, session_file))
+            emit(
+                attach_status_context(
+                    root,
+                    clear_current_task(root, args.agent, session_file),
+                    args.agent,
+                    session_file,
+                )
+            )
         elif command == "transition":
-            emit(transition_task(root, args.stage, args.agent, args.task_id, session_file))
+            emit(
+                attach_status_context(
+                    root,
+                    transition_task(root, args.stage, args.agent, args.task_id, session_file),
+                    args.agent,
+                    session_file,
+                )
+            )
         elif command == "close-current":
-            emit(close_current_task(root, args.reason, args.agent, session_file))
+            emit(
+                attach_status_context(
+                    root,
+                    close_current_task(root, args.reason, args.agent, session_file),
+                    args.agent,
+                    session_file,
+                )
+            )
         elif command == "project-init-complete":
-            emit(project_init_complete(root, args.agent))
+            emit(
+                attach_status_context(
+                    root,
+                    project_init_complete(root, args.agent),
+                    args.agent,
+                    session_file,
+                )
+            )
         elif command == "set-repo-path":
-            emit(set_repo_path(root, args.repo, args.path, args.task_id, session_file))
+            emit(
+                attach_status_context(
+                    root,
+                    set_repo_path(root, args.repo, args.path, args.task_id, session_file),
+                    None,
+                    session_file,
+                )
+            )
         return 0
     except StateError as error:
         print(json.dumps({"error": str(error)}, ensure_ascii=False), file=sys.stderr)

package/templates/shared-hooks/easy_coding_status.py

@@ -1,112 +1,7 @@
-from pathlib import Path
-
 from easy_coding_state import (
-    HELP_SUFFIX,
-    get_pending_init_version,
-    is_project_init_required,
-    record_seen_stage,
-    snapshot_state,
+    build_machine_breadcrumbs,
+    build_status_context,
+    build_status_line,
 )
 
-
-READY_LINE = (
-    "> **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"
-
-MANDATORY_DEV_SPEC_HEADERS: list[str] = [
-    "## 技术方案",
-    "### 项目模式",
-    "### 任务类型",
-    "### 需求解析",
-    "### 现状",
-    "### 冲突摘要",
-    "### 待用户决策",
-    "### 影响面分析",
-    "### 改动范围",
-    "### 修改方案",
-    "### 实施拆解",
-    "### 测试策略",
-    "### 风险与注意事项",
-]
-
-def build_status_line(root: Path, session: dict, agent: str | None = None) -> str:
-    state = snapshot_state(root, session=session)
-    task_id = state["current_task"]
-    if task_id:
-        status = str(state["status"])
-        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 state["is_terminal"] or state["task_missing"]:
-            line += f" · {HELP_SUFFIX}"
-        return line
-
-    if is_project_init_required(root):
-        return WAITING_INIT_LINE
-
-    pending = get_pending_init_version(root)
-    if pending:
-        return (
-            f"> **Easy Coding** · Waiting init · "
-            f"Upgrade to v{pending} — run `ec-init` to adapt"
-        )
-
-    return READY_LINE
-
-
-def build_machine_breadcrumbs(root: Path, session: dict, agent: str | None = None) -> list[str]:
-    state = snapshot_state(root, session=session)
-    task_id = state["current_task"]
-    task = state["task"]
-    stage = str(state["status"]) if task else "idle"
-    lines = [f"[workflow-state:{stage}]", f"[easy-coding:session-file:{state['session_file']}]"]
-
-    if task_id:
-        lines.append(f"[current-task:{task_id}]")
-        if state["task_missing"]:
-            lines.append(f"[easy-coding:current-task-missing:{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 is_project_init_required(root):
-        lines.append("[easy-coding:init-required]")
-    else:
-        pending = get_pending_init_version(root)
-        if pending:
-            lines.append(f"[easy-coding:upgrade-init-pending:{pending}]")
-
-    # Stage-specific reminders
-    if stage == "ANALYSIS" and task_id:
-        dev_spec = root / ".easy-coding" / "tasks" / str(task_id) / "dev-spec.md"
-        if dev_spec.exists():
-            try:
-                content = dev_spec.read_text(encoding="utf-8")
-                missing = [h for h in MANDATORY_DEV_SPEC_HEADERS if h not in content]
-                if missing:
-                    names = ",".join(h.lstrip("#").strip() for h in missing)
-                    lines.append(f"[easy-coding:analysis-template-drift:missing:{names}]")
-                else:
-                    lines.append("[easy-coding:analysis-template-ok]")
-            except OSError:
-                lines.append("[easy-coding:analysis-gate:skeleton-first-then-fill]")
-        else:
-            lines.append("[easy-coding:analysis-gate:skeleton-first-then-fill]")
-
-    # State machine validation
-    if task_id and task and task.get("status"):
-        current_stage = str(task["status"])
-        last_seen = session.get("last_seen_stage")
-        violation = record_seen_stage(root, str(task_id), current_stage)
-        if violation:
-            lines.append(f"[ILLEGAL-TRANSITION:{last_seen}->{current_stage}]")
-            lines.append(f"[easy-coding:transition-error:{violation}]")
-
-    return lines
-
-
-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)])
+__all__ = ["build_machine_breadcrumbs", "build_status_context", "build_status_line"]