opencode-codeops 2.1.0 → 2.2.0

package/scripts/codeops_plan.py

@@ -13,6 +13,7 @@ import re
 import sys
 from dataclasses import asdict, dataclass
 from pathlib import Path
+from typing import Iterator
 
 
 IMPLEMENTS_RE = re.compile(r"^>[ \t]*\*\*Implements\*\*:[ \t]*(.+?)[ \t]*$", re.MULTILINE)
@@ -21,7 +22,9 @@ TARGET_RE = re.compile(
     r"(?:RD-(?:[A-Za-z0-9]+-)*\d+|T-\d+|REQ-[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*)"
     r"(?![A-Za-z0-9_-])"
 )
-TASK_RE = re.compile(r"^-\s*\[([ xX~!])\]\s+(.+?)\s*$", re.MULTILINE)
+TASK_RE = re.compile(r"^-\s*\[([ xX~!])\]\s+(.+?)\s*$")
+FENCE_OPEN_RE = re.compile(r"^ {0,3}(`{3,}|~{3,})")
+TASK_ID_RE = re.compile(r"^\s*(?:\*\*)?([0-9]+\.[0-9]+\.[0-9]+|T-[0-9]+\.[0-9]+)(?=[\s*—–-]|$)")
 BLOCKED_REASON_RE = re.compile(r"(?:blocked|reason)\s*:\s*\S", re.IGNORECASE)
 _PROGRESS_WIDTH = 10
 _PROGRESS_FILLED = "█"
@@ -67,9 +70,70 @@ def parse_implements(index_text: str) -> tuple[str, ...]:
     return tuple(dict.fromkeys(TARGET_RE.findall(match.group(1))))
 
 
+def _task_lines(execution_text: str) -> Iterator[tuple[str, str, str]]:
+    """Yield ``(marker, text, task_id)`` for every real execution-task line.
+
+    A line qualifies when it carries one of the four checkbox markers outside a
+    fenced code block and its text begins with a task id. Fences follow the
+    Markdown shape: an opening run of three or more backticks or tildes (at
+    most three leading spaces, optional info string) hides everything up to a
+    closing run of the same character with at least the same length and nothing
+    else on the line; an unclosed fence hides the rest of the document. An id
+    is ``N.N.N`` or ``T-N.N`` after an optional ``**`` opener and must be
+    followed by whitespace, ``*``, a dash, or the end of the line, so
+    near-misses such as ``1.1.1.1``, ``T-05.1x``, and ``1.1.1:`` stay ignored.
+    Duplicate ids are yielded; the caller decides which occurrence counts.
+    """
+    fence_char = ""
+    fence_length = 0
+    for line in execution_text.splitlines():
+        line = line.rstrip()
+        if fence_char:
+            indent = len(line) - len(line.lstrip(" "))
+            body = line[indent:] if indent <= 3 else ""
+            if len(body) >= fence_length and body == fence_char * len(body):
+                fence_char = ""
+            continue
+        opener = FENCE_OPEN_RE.match(line)
+        if opener:
+            fence_char = opener.group(1)[0]
+            fence_length = len(opener.group(1))
+            continue
+        task = TASK_RE.match(line)
+        task_id = TASK_ID_RE.match(task.group(2)) if task else None
+        if task_id is None:
+            continue
+        yield task.group(1).lower(), task.group(2).strip(), task_id.group(1)
+
+
 def parse_tasks(execution_text: str) -> tuple[Task, ...]:
-    """Parse only the four authoritative execution checklist markers."""
-    return tuple(Task(marker.lower(), text.strip()) for marker, text in TASK_RE.findall(execution_text))
+    """Return the execution tasks a plan document really declares.
+
+    Fenced examples and checkbox lines without a task id (deliverable and
+    acceptance lists, quoted templates) are ignored, and a task id that appears
+    more than once counts once, from its first occurrence in document order.
+    """
+    tasks: list[Task] = []
+    seen: set[str] = set()
+    for marker, text, task_id in _task_lines(execution_text):
+        if task_id in seen:
+            continue
+        seen.add(task_id)
+        tasks.append(Task(marker, text))
+    return tuple(tasks)
+
+
+def has_checkbox_lines(execution_text: str) -> bool:
+    """Return whether a document carries at least one checklist line.
+
+    Presence is deliberately id-agnostic: legacy execution plans may list
+    tasks without ids, and migration admission must stay tolerant of them.
+    Counting correctness is ``parse_tasks``' job; this predicate only answers
+    "does the document look like it declares tasks at all". Fences are not
+    stripped here for the same reason — a quoted checklist still proves the
+    document format.
+    """
+    return any(TASK_RE.match(line.rstrip()) for line in execution_text.splitlines())
 
 
 def next_task(tasks: tuple[Task, ...]) -> Task | None:

package/scripts/codeops_plan_migrate.py

@@ -17,9 +17,21 @@ from dataclasses import dataclass
 from pathlib import Path
 
 try:
-    from scripts.codeops_plan import BLOCKED_REASON_RE, IMPLEMENTS_RE, parse_implements, parse_tasks
+    from scripts.codeops_plan import (
+        BLOCKED_REASON_RE,
+        IMPLEMENTS_RE,
+        has_checkbox_lines,
+        parse_implements,
+        parse_tasks,
+    )
 except ModuleNotFoundError:  # Direct execution adds scripts/, not the repository root, to sys.path.
-    from codeops_plan import BLOCKED_REASON_RE, IMPLEMENTS_RE, parse_implements, parse_tasks
+    from codeops_plan import (
+        BLOCKED_REASON_RE,
+        IMPLEMENTS_RE,
+        has_checkbox_lines,
+        parse_implements,
+        parse_tasks,
+    )
 
 
 TARGET_ID_RE = re.compile(
@@ -231,7 +243,9 @@ def inspect_migration(codeops_root: Path) -> Migration:
                 continue
             execution_text = execution.read_text(encoding="utf-8")
             tasks = parse_tasks(execution_text)
-            if not tasks:
+            # Presence stays checkbox-based (id-agnostic) so legacy id-less
+            # checklists keep migrating; only real tasks are checked further.
+            if not has_checkbox_lines(execution_text):
                 problems.append(f"{execution}: contains no execution tasks")
             for task in tasks:
                 if task.marker == "!" and not BLOCKED_REASON_RE.search(task.text):

package/skills/exec-plan/SKILL.md

@@ -172,6 +172,11 @@ For each task, in order:
    the Master Progress Checklist — see the protocol's dual-format detection) and bump the Progress
    counter / Last Updated stamp as soon as implementation finishes (crash-safe), promote it to
    `[x]` only after its verification passes. A task never shows `[x]` with a failing verify.
+
+   - **Report progress** — when the `codeops_progress` tool is available — at the transition
+     points in [execution-protocol.md](execution-protocol.md) §Progress Reporting; a failed or
+     missing report never blocks any step.
+
 3. **Verify** — run your project's verify command (from the project's AGENTS.md, or detected
    project conventions), output captured per the protocol's **Verify-output capture rule**
    (PASS one-liner; on failure the last 50 log lines + log path). Pass → promote `[~]` → `[x]`;

package/skills/exec-plan/execution-protocol.md

@@ -444,6 +444,35 @@ otherwise still `[~]` — with the progress counter and Last Updated stamp curre
 
 ---
 
+## Progress Reporting (fail-soft)
+
+While a plan executes, the agent may report live progress through the `codeops_progress` tool so
+the sidebar shows the current run. Reporting is an observability aid only: the Markdown execution
+plan remains the single progress source of truth, and a missing tool or a failed call never
+blocks, delays, or changes any verify, commit, or plan update — when the tool is unavailable,
+execution proceeds silently.
+
+Report at these moments; `plan` is the plan folder name, and every call carries `plan` and
+`activity` (absent optional fields are carried by the run state):
+
+| Moment | Report payload |
+| ------ | -------------- |
+| Run start (start point determined) | `{ plan, phase, task, activity: "implementing" }` |
+| Phase start (subsequent phases) | `{ plan, phase, activity: "starting" }` |
+| Task implemented (after the `[~]` mark) | `{ plan, task, activity: "implementing" }` |
+| Verification (before running verify) | `{ plan, activity: "verifying" }` |
+| Task verified (after `[x]` + the progress-bar display) | `{ plan, verified, total, activity: "implementing" }` — counts from that display |
+| Blocker (after the `[!]` mark) | `{ plan, activity: "blocked", detail: "<short reason>" }` |
+| Delegation (around an executor/reviewer dispatch) | `{ plan, activity: "delegating", detail: "<role>" }` |
+| Review step (post-phase quality loop) | `{ plan, activity: "reviewing" }` |
+| Waiting (before pausing for an explicit user decision) | `{ plan, activity: "waiting" }` |
+| Run done (all tasks complete) | `{ plan, activity: "done" }` |
+
+One call per listed moment, no other calls (noise control). A reporting failure or a host without
+the tool never blocks, delays, or changes any step.
+
+---
+
 ## Step 3: Session Wrap-Up
 
 1. Complete the current task before stopping.