fix(spec): generic implement workspace from checklist paths

Top-level disk listing plus checklist-named paths only — no layout
classifiers. Resume injects open implementation tasks; pathless steps
get explicit next-action guidance. Tests cover no-path steps and resume.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: agentpike

cecli/spec/focus.py

@@ -8,10 +8,9 @@
 from cecli.spec.implement import build_implement_workspace_block
 from cecli.spec.steering import (
     IMPLEMENTATION_TOOL_HINTS,
-    SCAFFOLD_MISSING_HINT,
+    SCAFFOLD_HINT,
     SPEC_FOCUS_INSTRUCTIONS,
     build_spec_focus_preamble,
-    workspace_lib_missing,
 )
 from cecli.spec.todos import (
     TodoItem,
@@ -85,9 +84,15 @@ def should_inject_task_context(
     focus_requested: bool,
     item: TodoItem | None,
     inject_todo_spec: bool,
+    agent_continuation: bool = False,
+    message: str | None = None,
 ) -> bool:
     if item is None:
         return False
+    if agent_continuation:
+        return False
+    if message and _is_resume_implement_message(message):
+        return False
     if inject_todo_spec:
         return True
     if not focus_requested:
@@ -137,6 +142,8 @@ def build_user_message_with_spec_context(
         focus_requested=focus_requested,
         item=item,
         inject_todo_spec=inject_todo_spec,
+        agent_continuation=agent_continuation,
+        message=message,
     ):
         assert item is not None
         turn_todo_id = item.id
@@ -154,8 +161,14 @@ def build_user_message_with_spec_context(
             if not agent_continuation:
                 blocks.append(build_spec_focus_preamble(workspace))
                 blocks.append(IMPLEMENTATION_TOOL_HINTS.strip())
-                if workspace_lib_missing(workspace):
-                    blocks.append(SCAFFOLD_MISSING_HINT.strip())
+                blocks.append(SCAFFOLD_HINT.strip())
+            if _is_resume_implement_message(message) and item is not None:
+                from cecli.spec.todos import _implementation_tasks_for_inject
+
+                blocks.append(
+                    "## Open implementation tasks (resume)\n"
+                    + _implementation_tasks_for_inject(item, max_open=4)
+                )
             checklist = item.checklist if item is not None else []
             blocks.append(
                 build_implement_workspace_block(

cecli/spec/implement.py

@@ -8,37 +8,25 @@
 import subprocess
 from pathlib import Path
 
-from cecli.spec.steering import workspace_lib_missing
 from cecli.spec.todos import ChecklistItem
 
 _PATH_IN_CHECKLIST = re.compile(
-    r"(?:`((?:lib|test)/[\w./-]+)`|((?:lib|test)/[\w./-]+))",
-    re.IGNORECASE,
+    r"`([^`\n]+)`|(?<![`\w])((?:[\w.-]+/)+[\w./-]+)",
 )
 
-_SNAPSHOT_DIRS = ("lib", "test")
-_MAX_LIST_FILES = 24
-
-
-def list_workspace_test_files(workspace: str | Path, *, limit: int = _MAX_LIST_FILES) -> list[str]:
-    return _list_tree_files(Path(workspace).resolve(), "test", limit=limit)
+_MAX_TOP_LEVEL = 20
 
+_SNAPSHOT_ORIENTATION = (
+    "- **Note:** Top-level listing is orientation only — do **not** ContextManager-add "
+    "these entries unless the checklist or implementation tasks name them."
+)
 
-def _list_tree_files(root: Path, subdir: str, *, limit: int = _MAX_LIST_FILES) -> list[str]:
-    base = root / subdir
-    if not base.is_dir():
-        return []
-    out: list[str] = []
-    for path in sorted(base.rglob("*")):
-        if not path.is_file():
-            continue
-        if path.name.startswith("."):
-            continue
-        rel = path.relative_to(root).as_posix()
-        out.append(rel)
-        if len(out) >= limit:
-            break
-    return out
+_NO_PATH_NEXT_ACTION = (
+    "This checklist item names **no file paths**. Use **## Implementation tasks** "
+    "(injected above) for deliverable paths for this step — pick **one missing file**, "
+    "then **ContextManager create** → **ReadRange** → **EditText**. "
+    "**Do not** skip to later numbered tasks."
+)
 
 
 def paths_from_checklist_text(text: str) -> list[str]:
@@ -48,6 +36,8 @@ def paths_from_checklist_text(text: str) -> list[str]:
         raw = (match.group(1) or match.group(2) or "").strip().rstrip("/")
         if not raw or raw in seen:
             continue
+        if "/" not in raw and not re.search(r"\.[a-z]{2,5}$", raw, re.IGNORECASE):
+            continue
         seen.add(raw)
         found.append(raw)
     return found
@@ -211,28 +201,19 @@ def resolve_implement_focus(
 
 
 def dart_test_paths_for_focus(workspace: str | Path, focus: ChecklistItem) -> list[str]:
-    """Best-effort test file paths for a checklist item mentioning tests."""
-    paths = paths_from_checklist_text(focus.text)
-    test_paths = [p for p in paths if p.startswith("test/") and p.endswith(".dart")]
-    if test_paths:
-        return test_paths[:4]
-    all_tests = list_workspace_test_files(workspace)
-    lower = focus.text.lower()
-    tokens = [
-        t
-        for t in re.split(r"[\W_]+", lower)
-        if len(t) > 3 and t not in {"write", "unit", "tests", "test", "for"}
-    ]
-    scored: list[tuple[int, str]] = []
-    for path in all_tests:
-        path_lower = path.lower()
-        score = sum(1 for tok in tokens if tok in path_lower)
-        if score:
-            scored.append((score, path))
-    if scored:
-        scored.sort(key=lambda x: (-x[0], x[1]))
-        return [p for _, p in scored[:4]]
-    return [f for f in all_tests if f.endswith("_test.dart")][:4]
+    """Dart test files explicitly named in the checklist and present on disk."""
+    root = Path(workspace).resolve()
+    if not (root / "pubspec.yaml").is_file():
+        return []
+    out: list[str] = []
+    for rel in paths_from_checklist_text(focus.text):
+        if not rel.endswith(".dart"):
+            continue
+        if deliverable_paths_exist(root, [rel]):
+            out.append(rel)
+        if len(out) >= 4:
+            break
+    return out
 
 
 def resolve_flutter_executable() -> str | None:
@@ -263,24 +244,29 @@ def build_workspace_snapshot_lines(workspace: str | Path) -> list[str]:
     lines = ["## Workspace snapshot (verified on disk — do **not** ls to rediscover)"]
     from cecli.spec.pubspec_repair import pubspec_repair_snapshot_lines
 
-    pubspec = root / "pubspec.yaml"
-    if pubspec.is_file():
-        lines.append("- `pubspec.yaml` — present")
-    else:
-        lines.append("- `pubspec.yaml` — **missing**")
+    try:
+        entries = sorted(root.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
+    except OSError:
+        entries = []
+    top_names = [
+        e.name + ("/" if e.is_dir() else "")
+        for e in entries[:_MAX_TOP_LEVEL]
+        if not e.name.startswith(".")
+    ]
+    if top_names:
+        preview = ", ".join(f"`{name}`" for name in top_names)
+        extra = f" (+{len(entries) - _MAX_TOP_LEVEL} more)" if len(entries) > _MAX_TOP_LEVEL else ""
+        lines.append(f"- **Top level:** {preview}{extra}")
 
-    for sub in _SNAPSHOT_DIRS:
-        files = _list_tree_files(root, sub)
-        if not files:
-            lines.append(f"- `{sub}/` — **empty or missing**")
-            continue
-        preview = ", ".join(f"`{f}`" for f in files[:8])
-        extra = f" (+{len(files) - 8} more)" if len(files) > 8 else ""
-        lines.append(f"- `{sub}/` — {len(files)} file(s): {preview}{extra}")
+    lines.append(_SNAPSHOT_ORIENTATION)
     lines.extend(pubspec_repair_snapshot_lines(root))
     return lines
 
 
+def _flutter_project(workspace: str | Path) -> bool:
+    return (Path(workspace).resolve() / "pubspec.yaml").is_file()
+
+
 def build_implement_next_action_lines(
     workspace: str | Path,
     checklist: list[ChecklistItem],
@@ -314,51 +300,57 @@ def build_implement_next_action_lines(
         )
     paths = paths_from_checklist_text(focus.text)
     on_disk = deliverable_paths_exist(workspace, paths) if paths else False
-    test_files = _list_tree_files(Path(workspace).resolve(), "test")
+    named_dart_tests = [
+        p for p in paths if p.endswith(".dart") and deliverable_paths_exist(workspace, [p])
+    ]
 
-    if is_test_related_checklist_text(focus.text) and test_files:
-        target = next((f for f in test_files if "test" in f), test_files[0])
-        lines.append(f"Focus checklist: **{focus.text.strip()}** — test file(s) already on disk.")
+    if is_test_related_checklist_text(focus.text) and named_dart_tests:
+        target = named_dart_tests[0]
+        lines.append(f"Focus checklist: **{focus.text.strip()}** — `{target}` is on disk.")
         lines.append(
             f"1. **ReadRange** `{target}` with `@000` / `000@` once\n"
-            f"2. **EditText** only if tests need fixes\n"
-            f"3. BrightVision runs **`flutter test`** at end of this turn — **do not** run flutter via Command\n"
-            f"4. Mark this checklist item done **only after** BrightVision reports tests passed\n"
-            f"**Do not** call ls, Grep, GitStatus, or repeat ReadRange on the same file."
+            f"2. **EditText** only if tests need fixes"
         )
-    elif on_disk and is_test_related_checklist_text(focus.text):
-        test_files = _list_tree_files(Path(workspace).resolve(), "test")
-        target = next((f for f in test_files if "test" in f), test_files[0] if test_files else None)
-        if target:
+        if _flutter_project(workspace):
             lines.append(
-                f"Focus checklist: **{focus.text.strip()}** — deliverable files already exist."
-            )
-            lines.append(
-                f"1. **ReadRange** `{target}` with `@000` / `000@` once\n"
-                f"2. **EditText** only if tests need fixes\n"
-                f"3. BrightVision runs **`flutter test`** at end of this turn — **do not** run flutter via Command\n"
-                f"4. Mark this checklist item done **only after** BrightVision reports tests passed\n"
-                f"**Do not** call ls, Grep, GitStatus, or repeat ReadRange on the same file."
+                "3. BrightVision runs **`flutter test`** at end of this turn — **do not** run flutter via Command\n"
+                "4. Mark this checklist item done **only after** BrightVision reports tests passed"
             )
         else:
-            lines.append(
-                f"Focus: **{focus.text.strip()}** — create tests with **ContextManager** + "
-                "**ReadRange** + **EditText** (one file). **No ls.**"
-            )
+            lines.append("3. Mark this checklist item done **only after** edits succeed")
+        lines.append("**Do not** call ls, Grep, GitStatus, or repeat ReadRange on the same file.")
+    elif is_test_related_checklist_text(focus.text) and paths and not on_disk:
+        lines.append(f"Focus checklist: **{focus.text.strip()}**")
+        lines.append(
+            "Create the test file(s) **named in this item** with **ContextManager create**, "
+            "then **ReadRange** + **EditText**. **No ls.**"
+        )
+    elif is_test_related_checklist_text(focus.text):
+        lines.append(f"Focus checklist: **{focus.text.strip()}**")
+        lines.append(
+            "Name target file path(s) in the checklist, then **ContextManager** / **ReadRange** / "
+            "**EditText** on **one** file. **No ls.**"
+        )
     elif on_disk:
-        target = paths[0] if paths else "lib/"
+        target = paths[0]
         lines.append(
             f"Focus checklist: **{focus.text.strip()}** — paths exist on disk (`{target}`)."
         )
         lines.append(
             "**ReadRange** the target source file, then **EditText** to finish. **No ls.**"
         )
-    elif workspace_lib_missing(workspace):
+    elif paths and not on_disk:
         lines.append(f"Focus checklist: **{focus.text.strip()}**")
         lines.append(
-            "**ContextManager** to scaffold `lib/` (and `test/` if needed), then **ReadRange** + "
-            "**EditText** on one file. **Do not ls** empty directories."
+            "Paths **named in this item** are not on disk yet — use **ContextManager create** "
+            "(not `add` on missing files), then **ReadRange** + **EditText** on **one** target file."
         )
+        lines.append(
+            "**Do not** ls, Grep, or ReadRange paths **not named** in this checklist item."
+        )
+    elif not paths:
+        lines.append(f"Focus checklist: **{focus.text.strip()}**")
+        lines.append(_NO_PATH_NEXT_ACTION)
     elif resume:
         lines.append(f"Focus checklist: **{focus.text.strip()}**")
         lines.append(

cecli/spec/steering.py

@@ -38,19 +38,15 @@
 - Do not mark implementation done until requirements pass EARS lint (WHEN/SHALL, no duplicate REQ ids).
 """
 
-SCAFFOLD_MISSING_HINT = """\
-## Workspace state (read before exploring)
+SCAFFOLD_HINT = """\
+## Scaffolding (this turn)
 
-`lib/` does **not** exist yet — scaffolding tasks (e.g. **1.1**, **1.2**) are incomplete.
-Do **not** repeat `ls` on `lib/` or `test/`. Use **ContextManager** to create directories/files,
-then **ReadRange** + **EditText**. If the active task is **1.3+**, complete **1.1** first.
+Use **ContextManager create** for **missing** paths **named in the checklist** (add on missing files is upgraded to create).
+Then **ReadRange** + **EditText** on **one** target file. **No ls.**
+Do not edit or ReadRange paths **not named** in the current checklist item.
 """
 
 
-def workspace_lib_missing(workspace: str | Path) -> bool:
-    return not (Path(workspace).resolve() / "lib").is_dir()
-
-
 IMPLEMENTATION_TOOL_HINTS = """\
 ## Implementation turn (tools)
 

cecli/spec/todos.py

@@ -251,6 +251,29 @@ def format_todo_context_light(item: TodoItem, *, store: TodoStore | None = None)
 
 
 _IMPLEMENT_DESIGN_MAX_CHARS = int(os.environ.get("BV_IMPLEMENT_DESIGN_MAX_CHARS", "4000"))
+_IMPLEMENT_TASKS_MAX_OPEN = int(os.environ.get("BV_IMPLEMENT_TASKS_MAX_OPEN", "12"))
+
+
+def _implementation_tasks_for_inject(item: TodoItem, *, max_open: int | None = None) -> str:
+    """Open checklist steps only — full tasks_md can be 20k+ tokens on local models."""
+    from cecli.spec.progress import implementation_steps
+
+    limit = max_open if max_open is not None else _IMPLEMENT_TASKS_MAX_OPEN
+    steps = implementation_steps(item)
+    open_steps = [s for s in steps if not s.done and s.step_id]
+    if not open_steps:
+        return _layer_or_placeholder(item.tasks_md, "(No implementation tasks yet.)")
+    shown = open_steps[: max(1, limit)]
+    lines: list[str] = []
+    for step in shown:
+        cur = " **(current)**" if step.current else ""
+        lines.append(f"- [ ] {step.step_id} {step.text.strip()}{cur}")
+    hidden = len(open_steps) - len(shown)
+    if hidden:
+        lines.append(
+            f"\n… {hidden} more open implementation step(s) — full list in Tasks / `.cecli/specs/`."
+        )
+    return "\n".join(lines)
 
 
 def _truncate_spec_layer(text: str, *, max_chars: int, label: str) -> str:
@@ -317,7 +340,7 @@ def format_todo_context_implement(item: TodoItem, *, store: TodoStore | None = N
         _truncate_spec_layer(item.design, max_chars=_IMPLEMENT_DESIGN_MAX_CHARS, label="design"),
         "",
         "## Implementation tasks",
-        _layer_or_placeholder(item.tasks_md, "(No implementation tasks yet.)"),
+        _implementation_tasks_for_inject(item),
     ]
     if item.checklist:
         _append_checklist_block(lines, item.checklist)