easy-coding-harness 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -6,6 +6,17 @@
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
+## 0.3.2
+
+- npm 包元数据切换到 GitHub：`repository`、`homepage` 和 `bugs.url` 均指向 `github.com/ysxiiun/easy-coding-harness`。
+
+## 0.3.1
+
+- 修复确认执行后首行状态栏仍显示上一阶段的问题：`UserPromptSubmit` hook 在明确确认输入下先执行合法状态迁移，再重新读取最新状态渲染状态栏。
+- `WAITING_CONFIRM -> IMPLEMENT` 和 `VERIFICATION -> MEMORY_SHORT` 采用状态前置策略，避免真实动作已经开始但 `task.json.status` 仍停留在旧阶段。
+- ec-workflow 强化统一规则：所有阶段推进必须先通过 state API 持久化下一阶段，再执行该阶段真实动作；hook 已完成前置迁移时不得重复写入。
+- README 中 CHANGELOG 超链接改为 GitHub `master` 文件地址，便于 npm 页面和外部用户访问。
+
 ## 0.3.0
 
 - 补充 `repository` / `homepage` / `bugs` 包元数据，并把 README 中的 CHANGELOG 链接改为 GitLab 绝对地址，修复 npm 页面相对链接跳转到 404 的问题。

package/README.md

@@ -135,7 +135,7 @@ easy-coding upgrade
 - `y`：常规功能升级
 - `z`：日常 bug 修复
 
-完整更新日志见 [CHANGELOG.md](https://gitlab.alibaba-inc.com/shixin.ysx/easy-coding-harness/-/blob/master/CHANGELOG.md)。
+完整更新日志见 [CHANGELOG.md](https://github.com/ysxiiun/easy-coding-harness/blob/master/CHANGELOG.md)。
 
 ## 开发者命令
 

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "easy-coding-harness",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CLI scaffold for installing Easy Coding harness files into agent-native directories.",
   "repository": {
     "type": "git",
-    "url": "git+https://gitlab.alibaba-inc.com/shixin.ysx/easy-coding-harness.git"
+    "url": "git+https://github.com/ysxiiun/easy-coding-harness.git"
   },
-  "homepage": "https://gitlab.alibaba-inc.com/shixin.ysx/easy-coding-harness#readme",
+  "homepage": "https://github.com/ysxiiun/easy-coding-harness#readme",
   "bugs": {
-    "url": "https://gitlab.alibaba-inc.com/shixin.ysx/easy-coding-harness/-/issues"
+    "url": "https://github.com/ysxiiun/easy-coding-harness/issues"
   },
   "type": "module",
   "bin": {

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

@@ -112,6 +112,12 @@ routing matches, and switching happens again.
 - **Never skip a stage.** ANALYSIS cannot jump to VERIFICATION; IMPLEMENT cannot start before
   WAITING_CONFIRM passes. No exception for "simple" tasks — simple tasks have short analyses,
   not skipped ones.
+- **State before action.** Every stage advance is a two-step protocol: first persist the
+  next stage through the state API, then run that stage's real work. Do not start analysis,
+  implementation, review, verification, memory writing, closeout, or task switching while
+  `task.json.status` still names the previous stage. After every state API call, treat the
+  returned snapshot/read-after-write state as authoritative for the next action and for the
+  status line.
 - **ANALYSIS entry gate.** When entering ANALYSIS, your FIRST TWO tool calls must be:
   (1) Read `.easy-coding/templates/dev-spec-skeleton.md`, then (2) Write its exact content
   to the task's dev-spec.md. This is a mechanical copy, not a generation task. Do not read
@@ -127,9 +133,15 @@ routing matches, and switching happens again.
   AND the user asked for autonomous execution. `auto_mode` ONLY waives this confirmation step;
   it carries NO scope or delivery-form decision. Never cite `auto_mode` (or "the user already
   decided in INIT") to justify narrowing scope or downgrading a code task to a report.
+  On confirmation, the harness hook may have already advanced the task to IMPLEMENT before
+  this reply is generated. If the breadcrumb/state is still WAITING_CONFIRM, call the state
+  API to transition to IMPLEMENT immediately; only after the read-after-write state says
+  IMPLEMENT may you dispatch ec-implementing.
 - **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.
+  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
   against the state machine. If you see `[ILLEGAL-TRANSITION:...]` in the injected context,
   you MUST revert the task's status to the previous valid stage and explain why the
@@ -145,6 +157,9 @@ routing matches, and switching happens again.
 - **Archive only after user acceptance.** VERIFICATION passing does not complete the task.
   After the user accepts, call state API transitions in order:
   MEMORY_SHORT → MEMORY_LONG → COMPLETE. Do not jump directly from VERIFICATION to COMPLETE.
+  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.
   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/inject-workflow-state.py

@@ -4,9 +4,103 @@ import os
 from pathlib import Path
 import sys
 
-from easy_coding_state import load_session
+from easy_coding_state import StateError, load_session, snapshot_state, transition_task
 from easy_coding_status import build_status_context
 
+PROMPT_KEYS = ("prompt", "user_prompt", "userPrompt", "message", "text", "input")
+
+NEGATIVE_OR_REVISION_PATTERNS = (
+    "修改",
+    "调整",
+    "重写",
+    "重新",
+    "补充",
+    "换个",
+    "换一",
+    "不要",
+    "别",
+    "取消",
+    "暂停",
+    "等一下",
+    "先别",
+    "有问题",
+    "还有问题",
+    "不对",
+    "不是",
+    "不行",
+    "继续修复",
+    "需要修复",
+    "再修复",
+    "修一下",
+    "修正",
+    "？",
+    "?",
+    "revise",
+    "change",
+    "cancel",
+    "pause",
+    "wait",
+    "stop",
+    "don't",
+    "do not",
+    "hold",
+    "problem",
+    "issue",
+    "keep fixing",
+    "continue fixing",
+    "needs fixing",
+)
+
+WAITING_CONFIRM_PATTERNS = (
+    "确认",
+    "开始",
+    "执行",
+    "实施",
+    "按方案",
+    "按计划",
+    "没问题",
+    "可以",
+    "同意",
+    "继续",
+    "go ahead",
+    "proceed",
+    "start",
+    "implement",
+    "approve",
+    "approved",
+    "yes",
+    "ok",
+    "okay",
+    "confirm",
+    "looks good",
+    "ship it",
+)
+
+VERIFICATION_ACCEPT_PATTERNS = (
+    "验收通过",
+    "接受",
+    "通过",
+    "可以结束",
+    "归档",
+    "完成",
+    "确认完成",
+    "没问题",
+    "可以",
+    "同意",
+    "accept",
+    "accepted",
+    "approve",
+    "approved",
+    "looks good",
+    "complete",
+    "finish",
+    "archive",
+    "done",
+    "ship it",
+)
+
+WAITING_CONFIRM_EXACT = {"1", "1.", "开始实施", "确认执行"}
+
 
 def configure_stdio() -> None:
     for stream in (sys.stdin, sys.stdout, sys.stderr):
@@ -21,6 +115,56 @@ def read_payload() -> dict:
         return {}
 
 
+def coerce_prompt_text(value: object) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        return "\n".join(part for item in value if (part := coerce_prompt_text(item)))
+    if isinstance(value, dict):
+        parts: list[str] = []
+        for key in PROMPT_KEYS:
+            if key in value:
+                text = coerce_prompt_text(value[key])
+                if text:
+                    parts.append(text)
+        if "content" in value:
+            text = coerce_prompt_text(value["content"])
+            if text:
+                parts.append(text)
+        return "\n".join(parts)
+    return ""
+
+
+def extract_user_prompt(payload: dict) -> str:
+    for key in PROMPT_KEYS:
+        if key not in payload:
+            continue
+        text = coerce_prompt_text(payload[key])
+        if text:
+            return text
+    return ""
+
+
+def normalize_prompt(text: str) -> str:
+    return " ".join(text.casefold().strip().split())
+
+
+def has_any(text: str, patterns: tuple[str, ...]) -> bool:
+    return any(pattern in text for pattern in patterns)
+
+
+def infer_confirmed_transition(current_stage: str, prompt: str) -> str | None:
+    normalized = normalize_prompt(prompt)
+    if not normalized or has_any(normalized, NEGATIVE_OR_REVISION_PATTERNS):
+        return None
+    if current_stage == "WAITING_CONFIRM":
+        if normalized in WAITING_CONFIRM_EXACT or has_any(normalized, WAITING_CONFIRM_PATTERNS):
+            return "IMPLEMENT"
+    if current_stage == "VERIFICATION" and has_any(normalized, VERIFICATION_ACCEPT_PATTERNS):
+        return "MEMORY_SHORT"
+    return None
+
+
 def find_ec_root(start: Path) -> Path | None:
     current = start.resolve()
     while True:
@@ -46,6 +190,35 @@ def detect_agent() -> str:
     return "unknown"
 
 
+def preflight_confirmed_transition(root: Path, session: dict, payload: dict, agent: str) -> dict:
+    prompt = extract_user_prompt(payload)
+    if not prompt:
+        return session
+
+    state = snapshot_state(root, session=session)
+    task_id = state.get("current_task")
+    if not task_id or state.get("task_missing") or state.get("is_terminal"):
+        return session
+
+    target_stage = infer_confirmed_transition(str(state.get("status") or ""), prompt)
+    if not target_stage:
+        return session
+
+    try:
+        transition_task(
+            root,
+            target_stage,
+            agent,
+            task_id=str(task_id),
+            session_file=str(state["session_file"]),
+        )
+    except StateError:
+        return load_session(root) or session
+
+    # Read after write so the status line renders the authoritative latest stage.
+    return load_session(root) or session
+
+
 def emit(event_name: str, context: str) -> None:
     print(
         json.dumps(
@@ -75,7 +248,10 @@ def main() -> int:
         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, session, detect_agent()))
+    agent = detect_agent()
+    if event_name == "UserPromptSubmit":
+        session = preflight_confirmed_transition(root, session, payload, agent)
+    emit(event_name, build_status_context(root, session, agent))
     return 0