@caddis/cli 0.4.69 → 0.4.70

package/bundles/antigravity-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "caddis",
-  "version": "1.3.155",
+  "version": "1.3.156",
   "description": "caddis — agent-agnostic dev harness as an Antigravity (agy) plugin: TDD skills + commands, single-sourced with the Claude Code plugin."
 }

package/bundles/antigravity-plugin/scripts/caddis_budget.py

@@ -52,12 +52,6 @@ BUDGETS: tuple[Budget, ...] = (
         60,
         "rendered by render-index; drop relays with status closed",
     ),
-    Budget(
-        ".caddis/open-work.md",
-        "rows with Status done",
-        10,
-        "move done rows to .caddis/done/open-work-archive.md with a one-line pointer",
-    ),
     Budget(
         "DECISIONS.md, .caddis/DECISIONS.md, .caddis/decisions/DECISIONS.md",  # the last is the fleet's real path
         "History table rows",
@@ -150,36 +144,6 @@ def _count_table_rows(text: str) -> int:
     return sum(len(t.data_rows) for t in tables) + loose_rows
 
 
-def _norm_status(cell: str) -> str:
-    return cell.replace("**", "").replace("__", "").replace("`", "").strip().lower()
-
-
-def _count_done_rows(text: str) -> int:
-    tables, _ = _parse_tables(text)
-    done_re = re.compile(r"^done\b")
-    count = 0
-    if tables:
-        for t in tables:
-            col_map = {c.lower(): idx for idx, c in enumerate(t.columns)}
-            if "status" in col_map:
-                s_idx = col_map["status"]
-                for row in t.data_rows:
-                    if len(row) > s_idx and done_re.search(_norm_status(row[s_idx])):
-                        count += 1
-            else:
-                for row in t.data_rows:
-                    if any(_norm_status(c) == "done" for c in row):
-                        count += 1
-        return count
-
-    for line in text.splitlines():
-        if line.lstrip().startswith("|") and not _is_separator(line):
-            cells = _split_cells(line)
-            if any(_norm_status(c) == "done" for c in cells):
-                count += 1
-    return count
-
-
 def _count_history_rows(text: str) -> int:
     tables, loose_rows = _parse_tables(text)
     history_tables = [t for t in tables if t.heading and "history" in t.heading.lower()]
@@ -198,8 +162,6 @@ def _measure_file(path: Path, unit: str) -> int:
         return _count_table_rows(text)
     if unit in ("lines", "lines per file"):
         return len(text.splitlines())
-    if unit == "rows with Status done":
-        return _count_done_rows(text)
     if unit == "History table rows":
         return _count_history_rows(text)
     raise ValueError(f"unknown budget unit: {unit}")

package/bundles/antigravity-plugin/scripts/caddis_roadmap_run.py

@@ -11,7 +11,7 @@ line; decide. CONTINUE with an unchanged relay is `FAILED no progress`; three se
 row is `BLOCKED stuck`.
 
 Plan mode (`--plan <slug>`, decision D-I, design section 8.5) runs `.caddis/plans/<slug>.md`. A closed row in its
-tracker or in `.caddis/open-work.md` is progress; the relay is `.caddis/relay/<slug>.md`; the log and STOP file are in
+tracker is progress (`.caddis/open-work.md` is retired with the 3-store model, 21 Oct 2026); the relay is `.caddis/relay/<slug>.md`; the log and STOP file are in
 `.caddis/plans/.local/<slug>/`; the lock is `<git common dir>/caddis-runner/plan-<slug>/runner.lock`. The loop goes on only
 at CONTINUE. Its lock holds the whole plan (`batch` `<slug>#*`). A plan that another live runner lock names is refused
 (exit 3 at start, 1 at any later iteration: the check runs before every session).
@@ -322,8 +322,7 @@ def resolve_target(repo: Path, plan: str | None) -> Target:
     plan_file = repo / ".caddis" / "plans" / f"{slug}.md"
     if not plan_file.is_file():
         raise ValueError(f"no plan {slug!r}: {plan_file} does not exist")
-    return Target("plan", slug, _local_dir(repo, "plan", slug), (plan_file, repo / ".caddis" / "open-work.md"),
-                  PLAN_PROMPT_NAME)
+    return Target("plan", slug, _local_dir(repo, "plan", slug), (plan_file,), PLAN_PROMPT_NAME)
 
 
 def render_prompt(template: Path, slug: str, phase: int | None = None) -> str:
@@ -337,13 +336,13 @@ def render_prompt(template: Path, slug: str, phase: int | None = None) -> str:
     return body.strip() + "\n"
 
 
-# -- open work: closed rows -------------------------------------------------------------------------------------------
+# -- closed rows ------------------------------------------------------------------------------------------------------
 
 
-def closed_rows(open_work: Path) -> int:
+def closed_rows(path: Path) -> int:
     """Rows whose `Status` column (by name) is done or not-needed, over every table of the file."""
     try:
-        lines = open_work.read_text(encoding="utf-8").splitlines()
+        lines = path.read_text(encoding="utf-8").splitlines()
     except OSError:
         return 0
     count, status_col = 0, None

package/bundles/antigravity-plugin/scripts/caddis_rows.py

@@ -1,34 +1,16 @@
-"""Set open-work table cells by row id and column name; archive done rows."""
+"""Split a markdown table line into cells (caddis_roadmap reads its tables with this).
+
+The `set` and `archive-done` sub-commands edited `.caddis/open-work.md`. They are retired with the
+3-store model (owner decision, 21 Oct 2026): caddis no longer reads or writes open-work.md. Running the
+script prints one line and changes nothing, so an older /handoff that still calls `set` does not fail.
+"""
 
 from __future__ import annotations
 
-import argparse
-from dataclasses import dataclass
-import json
-import os
-from pathlib import Path
 import re
 import sys
-import tempfile
-
-try:
-    import caddis_exit
-except ModuleNotFoundError as exc:
-    if exc.name != "caddis_exit":
-        raise
-    sys.path.insert(0, str(Path(__file__).resolve().parent))
-    sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "claude-harness" / "scripts"))
-    import caddis_exit
-
 
-@dataclass
-class Table:
-    heading: str | None
-    header_line_idx: int
-    separator_line_idx: int
-    data_line_indices: list[int]
-    columns: list[str]
-    id_col_idx: int | None
+RETIRED = "caddis_rows: set and archive-done are retired (3-store model); nothing changed"
 
 
 def split_cells(line: str) -> list[str]:
@@ -44,433 +26,10 @@ def split_cells(line: str) -> list[str]:
     return [p.strip() for p in parts]
 
 
-def _is_separator(line: str) -> bool:
-    cells = split_cells(line)
-    if not cells:
-        return False
-    for cell in cells:
-        c = cell.strip()
-        if not c:
-            return False
-        if any(ch not in "-: " for ch in c):
-            return False
-        if "-" not in c:
-            return False
-    return True
-
-
-def find_tables(lines: list[str]) -> list[Table]:
-    tables: list[Table] = []
-    n = len(lines)
-    i = 0
-    while i < n:
-        if lines[i].startswith("|"):
-            run_start = i
-            while i < n and lines[i].startswith("|"):
-                i += 1
-            run_end = i
-            run_lines = lines[run_start:run_end]
-            if len(run_lines) >= 2 and _is_separator(run_lines[1]):
-                header_idx = run_start
-                sep_idx = run_start + 1
-                data_indices = list(range(run_start + 2, run_end))
-                columns = split_cells(lines[header_idx])
-
-                heading = None
-                for k in range(run_start - 1, -1, -1):
-                    s = lines[k].strip()
-                    if s.startswith("#"):
-                        heading = s.lstrip("#").strip()
-                        break
-
-                id_col_idx = None
-                for col_idx, col in enumerate(columns):
-                    if col.lower() == "id":
-                        id_col_idx = col_idx
-                        break
-
-                tables.append(
-                    Table(
-                        heading=heading,
-                        header_line_idx=header_idx,
-                        separator_line_idx=sep_idx,
-                        data_line_indices=data_indices,
-                        columns=columns,
-                        id_col_idx=id_col_idx,
-                    )
-                )
-        else:
-            i += 1
-    return tables
-
-
-def _atomic_write_bytes(target: Path, data: bytes) -> None:
-    target = target.resolve()
-    temp_path: Path | None = None
-    try:
-        with tempfile.NamedTemporaryFile(
-            dir=target.parent, prefix=f".{target.name}.", suffix=".tmp", delete=False
-        ) as f:
-            temp_path = Path(f.name)
-            f.write(data)
-            f.flush()
-            os.fsync(f.fileno())
-        os.replace(temp_path, target)
-        temp_path = None
-    finally:
-        if temp_path is not None and temp_path.exists():
-            try:
-                temp_path.unlink()
-            except OSError:
-                pass
-
-
-def _norm_id(cell: str) -> str:
-    return cell.replace("**", "").replace("__", "").replace("`", "").strip()
-
-
-def handle_set(args: argparse.Namespace) -> int:
-    if not args.id and not args.from_file:
-        print("caddis-rows: either --id or --from is required", file=sys.stderr)
-        return caddis_exit.ERROR
-    if args.id and not args.col:
-        print("caddis-rows: --id requires at least one --col", file=sys.stderr)
-        return caddis_exit.ERROR
-    if args.id and args.from_file:
-        print("caddis-rows: cannot specify both --id and --from", file=sys.stderr)
-        return caddis_exit.ERROR
-
-    change_specs: list[dict] = []
-    if args.id:
-        cols_dict: dict[str, str] = {}
-        for c in args.col:
-            if "=" not in c:
-                print(f"caddis-rows: invalid --col format '{c}', expected NAME=VALUE", file=sys.stderr)
-                return caddis_exit.ERROR
-            name, val = c.split("=", 1)
-            name = name.strip()
-            cols_dict[name] = val
-        change_specs.append({"id": args.id, "table": args.table, "cols": cols_dict})
-    else:
-        from_path = Path(args.from_file)
-        if from_path.is_file():
-            try:
-                content = from_path.read_text(encoding="utf-8")
-                loaded = json.loads(content)
-            except (OSError, json.JSONDecodeError) as exc:
-                print(f"caddis-rows: failed to read --from file: {exc}", file=sys.stderr)
-                return caddis_exit.ERROR
-        else:
-            try:
-                loaded = json.loads(args.from_file)
-            except json.JSONDecodeError as exc:
-                print(f"caddis-rows: invalid JSON in --from: {exc}", file=sys.stderr)
-                return caddis_exit.ERROR
-
-        if not isinstance(loaded, list):
-            print("caddis-rows: --from JSON must be a list of change objects", file=sys.stderr)
-            return caddis_exit.ERROR
-
-        for item in loaded:
-            if not isinstance(item, dict) or "id" not in item or "cols" not in item or not isinstance(item["cols"], dict):
-                print(f"caddis-rows: invalid item in --from: {item}", file=sys.stderr)
-                return caddis_exit.ERROR
-            tbl = item.get("table") or args.table
-            change_specs.append({"id": item["id"], "table": tbl, "cols": dict(item["cols"])})
-
-    for spec in change_specs:
-        for val in spec["cols"].values():
-            val_str = str(val)
-            if "\n" in val_str or "\r" in val_str:
-                print("caddis-rows: value contains newline characters", file=sys.stderr)
-                return caddis_exit.ERROR
-
-    file_path = Path(args.file)
-    if not file_path.exists():
-        print(f"caddis-rows: file not found: {file_path}", file=sys.stderr)
-        return caddis_exit.BLOCKED
-
-    raw = file_path.read_bytes()
-    text = raw.decode("utf-8")
-    crlf = "\r\n" in text
-    newline = "\r\n" if crlf else "\n"
-    ends_with_newline = text.endswith(newline)
-    if ends_with_newline:
-        content = text[:-len(newline)]
-    else:
-        content = text
-    lines = content.split(newline) if content else []
-
-    tables = find_tables(lines)
-
-    # Validate all changes
-    validated_changes: list[dict] = []
-    for spec in change_specs:
-        item_id = spec["id"]
-        table_filter = spec.get("table")
-        cols = spec["cols"]
-
-        candidate_tables = [t for t in tables if t.id_col_idx is not None]
-        if not candidate_tables:
-            print(
-                f"caddis-rows: {file_path}: no table has a column named ID; an open-work table needs | ID | ... | Status |",
-                file=sys.stderr,
-            )
-            return caddis_exit.BLOCKED
-        if table_filter is not None:
-            candidate_tables = [t for t in candidate_tables if t.heading == table_filter]
-
-        candidates: list[tuple[Table, int, list[str]]] = []
-        for t in candidate_tables:
-            for line_idx in t.data_line_indices:
-                cells = split_cells(lines[line_idx])
-                if len(cells) > t.id_col_idx and _norm_id(cells[t.id_col_idx]) == _norm_id(item_id):
-                    candidates.append((t, line_idx, cells))
-
-        if len(candidates) == 0:
-            print(f"caddis-rows: row id '{item_id}' not found", file=sys.stderr)
-            return caddis_exit.BLOCKED
-
-        if len(candidates) > 1:
-            headings = [c[0].heading for c in candidates]
-            print(f"caddis-rows: row id '{item_id}' found in multiple tables: {headings}", file=sys.stderr)
-            return caddis_exit.BLOCKED
-
-        cand_table, cand_line_idx, cand_cells = candidates[0]
-
-        col_lookup = {col.lower(): idx for idx, col in enumerate(cand_table.columns)}
-        for col_name in cols:
-            if col_name.lower() not in col_lookup:
-                print(f"caddis-rows: column '{col_name}' not found in table '{cand_table.heading}'", file=sys.stderr)
-                return caddis_exit.BLOCKED
-
-        validated_changes.append({
-            "id": item_id,
-            "table": cand_table,
-            "line_idx": cand_line_idx,
-            "cols": cols,
-        })
-
-    # Apply changes
-    row_cells: dict[int, list[str]] = {}
-    original_cells: dict[int, list[str]] = {}
-    applied_notifications: list[str] = []
-
-    for v in validated_changes:
-        cand_table: Table = v["table"]
-        line_idx: int = v["line_idx"]
-        cols: dict[str, str] = v["cols"]
-        item_id: str = v["id"]
-
-        if line_idx not in row_cells:
-            cells = split_cells(lines[line_idx])
-            if len(cells) < len(cand_table.columns):
-                cells.extend([""] * (len(cand_table.columns) - len(cells)))
-            row_cells[line_idx] = cells
-            original_cells[line_idx] = list(cells)
-
-        current_cells = row_cells[line_idx]
-        col_lookup = {col.lower(): idx for idx, col in enumerate(cand_table.columns)}
-
-        for col_name, raw_val in cols.items():
-            col_idx = col_lookup[col_name.lower()]
-            canonical_col_name = cand_table.columns[col_idx]
-            escaped_val = re.sub(r"(?<!\\)\|", r"\|", str(raw_val))
-            if current_cells[col_idx] != escaped_val:
-                current_cells[col_idx] = escaped_val
-                applied_notifications.append(f"set {item_id} {canonical_col_name}={raw_val}")
-
-    any_changed = False
-    for line_idx, cells in row_cells.items():
-        if cells != original_cells[line_idx]:
-            lines[line_idx] = "| " + " | ".join(cells) + " |"
-            any_changed = True
-
-    if any_changed:
-        output_text = newline.join(lines)
-        if ends_with_newline and lines:
-            output_text += newline
-        _atomic_write_bytes(file_path, output_text.encode("utf-8"))
-
-    for note in applied_notifications:
-        print(note)
-
-    return caddis_exit.CLEAN
-
-
-def handle_archive_done(args: argparse.Namespace) -> int:
-    file_path = Path(args.file)
-    if not file_path.exists():
-        print(f"caddis-rows: file not found: {file_path}", file=sys.stderr)
-        return caddis_exit.BLOCKED
-
-    raw = file_path.read_bytes()
-    text = raw.decode("utf-8")
-    crlf = "\r\n" in text
-    newline = "\r\n" if crlf else "\n"
-    ends_with_newline = text.endswith(newline)
-    if ends_with_newline:
-        content = text[:-len(newline)]
-    else:
-        content = text
-    lines = content.split(newline) if content else []
-
-    tables = find_tables(lines)
-    open_heading = args.open
-    closed_heading = args.closed
-
-    open_table = None
-    closed_table = None
-    for t in tables:
-        if t.heading == open_heading and open_table is None:
-            open_table = t
-        if t.heading == closed_heading and closed_table is None:
-            closed_table = t
-
-    if open_table is None:
-        print(f"caddis-rows: open table '{open_heading}' not found", file=sys.stderr)
-        return caddis_exit.BLOCKED
-
-    if closed_table is None:
-        print(f"caddis-rows: closed table '{closed_heading}' not found", file=sys.stderr)
-        return caddis_exit.BLOCKED
-
-    if open_table is closed_table:
-        print("caddis-rows: open table and closed table must be distinct", file=sys.stderr)
-        return caddis_exit.BLOCKED
-
-    open_col_map = {c.lower(): idx for idx, c in enumerate(open_table.columns)}
-    if "status" not in open_col_map:
-        print(f"caddis-rows: open table '{open_heading}' has no Status column", file=sys.stderr)
-        return caddis_exit.BLOCKED
-
-    status_idx = open_col_map["status"]
-    archivable_pattern = re.compile(r"^(done|not-needed)\b")
-
-    archivable_indices: list[int] = []
-    archived_ids: list[str] = []
-
-    for line_idx in open_table.data_line_indices:
-        cells = split_cells(lines[line_idx])
-        status_val = cells[status_idx].strip().lower() if len(cells) > status_idx else ""
-        if archivable_pattern.search(status_val):
-            archivable_indices.append(line_idx)
-            row_id = (
-                cells[open_table.id_col_idx]
-                if (open_table.id_col_idx is not None and len(cells) > open_table.id_col_idx)
-                else ""
-            )
-            archived_ids.append(row_id)
-
-    if not archivable_indices:
-        return caddis_exit.CLEAN
-
-    same_headers = (open_table.columns == closed_table.columns)
-    new_closed_lines: list[str] = []
-
-    if same_headers:
-        for idx in archivable_indices:
-            new_closed_lines.append(lines[idx])
-    else:
-        closed_col_map = {c.lower(): idx for idx, c in enumerate(closed_table.columns)}
-        dropped = [col for col in open_table.columns if col.lower() not in closed_col_map]
-        if dropped:
-            print(f"dropped columns: {', '.join(dropped)}")
-
-        for idx in archivable_indices:
-            cells = split_cells(lines[idx])
-            open_vals = {
-                col.lower(): (cells[i] if i < len(cells) else "")
-                for i, col in enumerate(open_table.columns)
-            }
-            row_cells = []
-            for col in closed_table.columns:
-                val = open_vals.get(col.lower())
-                if val is None or val == "":
-                    val = "-"
-                row_cells.append(val)
-            new_closed_lines.append("| " + " | ".join(row_cells) + " |")
-
-    archivable_set = set(archivable_indices)
-    insert_after_idx = (
-        closed_table.data_line_indices[-1]
-        if closed_table.data_line_indices
-        else closed_table.separator_line_idx
-    )
-
-    result_lines: list[str] = []
-    for idx, line in enumerate(lines):
-        if idx not in archivable_set:
-            result_lines.append(line)
-        if idx == insert_after_idx:
-            result_lines.extend(new_closed_lines)
-
-    output_text = newline.join(result_lines)
-    if ends_with_newline and result_lines:
-        output_text += newline
-    _atomic_write_bytes(file_path, output_text.encode("utf-8"))
-
-    for rid in archived_ids:
-        print(f"archived {rid}")
-
-    return caddis_exit.CLEAN
-
-
 def main(argv: list[str] | None = None) -> int:
-    if sys.stdout and hasattr(sys.stdout, "reconfigure"):
-        try:
-            sys.stdout.reconfigure(encoding="utf-8")
-        except Exception:
-            pass
-    if sys.stderr and hasattr(sys.stderr, "reconfigure"):
-        try:
-            sys.stderr.reconfigure(encoding="utf-8")
-        except Exception:
-            pass
-
-    if argv is None:
-        argv = sys.argv[1:]
-
-    parser = argparse.ArgumentParser(prog="caddis_rows", exit_on_error=False)
-    subparsers = parser.add_subparsers(dest="subcommand")
-
-    set_parser = subparsers.add_parser("set", exit_on_error=False)
-    set_parser.add_argument("--file", required=True)
-    set_parser.add_argument("--id")
-    set_parser.add_argument("--col", action="append", default=[])
-    set_parser.add_argument("--from", dest="from_file")
-    set_parser.add_argument("--table")
-
-    archive_parser = subparsers.add_parser("archive-done", exit_on_error=False)
-    archive_parser.add_argument("--file", required=True)
-    archive_parser.add_argument("--open", default="Open")
-    archive_parser.add_argument("--closed", default="Closed")
-
-    try:
-        args = parser.parse_args(argv)
-    except (argparse.ArgumentError, argparse.ArgumentTypeError) as exc:
-        print(f"caddis-rows: {exc}", file=sys.stderr)
-        return caddis_exit.ERROR
-    except SystemExit as exc:
-        code = exc.code if isinstance(exc.code, int) else 0
-        return caddis_exit.ERROR if code != 0 else 0
-
-    if not args.subcommand:
-        print("caddis-rows: subcommand required (set, archive-done)", file=sys.stderr)
-        return caddis_exit.ERROR
-
-    try:
-        if args.subcommand == "set":
-            return handle_set(args)
-        elif args.subcommand == "archive-done":
-            return handle_archive_done(args)
-        else:
-            print(f"caddis-rows: unknown subcommand '{args.subcommand}'", file=sys.stderr)
-            return caddis_exit.ERROR
-    except (OSError, UnicodeError, ValueError) as exc:
-        print(f"caddis-rows: {exc}", file=sys.stderr)
-        return caddis_exit.BLOCKED
+    print(RETIRED)
+    return 0
 
 
 if __name__ == "__main__":
-    raise SystemExit(main())
+    raise SystemExit(main(sys.argv[1:]))

package/bundles/antigravity-plugin/scripts/caddis_tidy.py

@@ -89,7 +89,7 @@ except ModuleNotFoundError as exc:
         raise
     sys.path.insert(0, str(Path(__file__).resolve().parent))
     import caddis_todo
-# caddis_todo has put its own dependencies on the path by now; this one ships beside it.
+# caddis_todo (through caddis_workstreams) has put its own dependencies on the path by now; this one ships beside it.
 from caddis_file_lock import atomic_write  # noqa: E402
 
 # No child process opens a console window on Windows (this runs under hooks and status lines that
@@ -160,9 +160,8 @@ def _parse_frontmatter(text: str) -> dict:
 def tracker_complete(text: str) -> bool:
     """True only when the `## Tracker` heading line has phase rows, all unique, all done.
 
-    The table is read by caddis_todo.tracker_table, the same reader the open-work view uses, and
-    a status cell is judged by the same `_is_done`. Stricter here on purpose: that view skips a
-    row it cannot read, while a row this cannot read BLOCKS completion. Wrongly moving a live plan
+    The table is read by caddis_todo.tracker_table, and a status cell is judged by its `_is_done`.
+    Strict on purpose: a row this cannot read BLOCKS completion. Wrongly moving a live plan
     hides it; wrongly keeping a finished one costs a look.
     """
     table = caddis_todo.tracker_table(text)
@@ -476,9 +475,9 @@ class Resolution:
 def _parked_target(root: Path, name: str) -> tuple[Path | None, str | None]:
     """Where a trailer value points: (open item, None), (None, None) when it is already in done/,
     or (None, reason) when it is refused or missing. Only a top-level item of this repo's
-    `.caddis/parking-lot/` is ever a target, named bare, as `parking-lot/<file>` (what
-    `caddis_todo.py done` prints) or by its repo-relative path. The last word is
-    caddis_todo._resolves_path, the check `caddis_todo add --resolves` already applies."""
+    `.caddis/parking-lot/` is ever a target, named bare, as `parking-lot/<file>` (what the
+    retired `caddis_todo.py done` printed) or by its repo-relative path. The last word is
+    caddis_todo._resolves_path."""
     lot = root / ".caddis" / PARKING_LOT_DIR
     posix = name.replace("\\", "/")
     if not posix:

package/bundles/antigravity-plugin/scripts/caddis_todo.py

@@ -1,29 +1,32 @@
-"""Locked, local to-do lists and a read-only view of active plan work."""
+"""The active plan and the plan Tracker reader, for commands, tidy and the gates.
+
+3-store model (owner decision, 21 Oct 2026): the session task list (`.caddis/relay/<name>.tasks.md`), the
+parking lot and the roadmap with the plan Tracker. The `.caddis/todo-list/` store and the open-work view
+are retired, with the `add`, `done`, `list` and `open-work` sub-commands. `reconcile` stays one more
+release as a no-op, because an older /handoff still calls it from its Step 6.
+"""
 
 from __future__ import annotations
 
 import argparse
-import json
 import os
 import re
 import subprocess
 import sys
-import uuid
 from pathlib import Path
 
 try:
     import caddis_exit
-    from caddis_file_lock import atomic_write, locked_path, retry_denied
-    from caddis_frontmatter import parse, split_document
+    from caddis_frontmatter import parse
     from caddis_workstreams import _artifact, _name
 except ModuleNotFoundError as exc:
     if exc.name not in {"caddis_exit", "caddis_file_lock", "caddis_frontmatter", "caddis_workstreams"}:
         raise
+    # caddis_tidy imports caddis_file_lock after this module: these two folders stay on the path.
     sys.path.insert(0, str(Path(__file__).resolve().parent))
     sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "claude-harness" / "scripts"))
     import caddis_exit
-    from caddis_file_lock import atomic_write, locked_path, retry_denied
-    from caddis_frontmatter import parse, split_document
+    from caddis_frontmatter import parse
     from caddis_workstreams import _artifact, _name
 
 
@@ -31,81 +34,9 @@ except ModuleNotFoundError as exc:
 # have no console). Inline, not scripts/no_window.py: in the source tree this file does not sit beside it.
 _NO_WINDOW = 0x08000000 if os.name == "nt" else 0
 
-_ITEM = re.compile(r'^- \[([ x])\] (.+?) <!-- caddis: (\{.*\}) -->$')
 _PHASE = re.compile(r'^\|\s*(\d+)\s*\|', re.M)
-_WORD = re.compile(r'[a-z0-9]{3,}')
 _PLAN_NAME = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,150}")
-# Trailing status markers on phase headings: arrows/clocks (U+2300-U+27BF), emoji, VS16.
-_STATUS_MARKER = re.compile("[\\s\u2300-\u27bf\U0001f300-\U0001faff\ufe0f]+$")
-
-
-def _path(root: Path, workstream: str | None) -> tuple[Path, Path]:
-    artifact = _artifact(root)
-    name = _name(workstream) if workstream is not None else "inbox"
-    folder = artifact / "todo-list"
-    # Only a folder that EXISTS can point elsewhere. Resolving one that does not exist yet raced a concurrent
-    # writer creating it: on Windows the two paths could resolve differently (a short 8.3 name on one side), and a
-    # safe add failed with this error (main CI, 20 Oct 2026, test_concurrent_inbox_add_loses_no_item).
-    if folder.is_symlink() or (folder.exists() and not folder.resolve().is_relative_to(artifact.resolve())):
-        raise ValueError("todo-list path escapes artifact root")
-    path = folder / f"{name}.md"
-    # Reads are unlocked, so refuse here as well as in locked_path. On Windows a writer replacing the file
-    # makes this probe (and the read below) fail with PermissionError for an instant, so both retry.
-    if retry_denied(path.is_symlink):
-        raise ValueError("to-do file may not be a symlink")
-    return artifact, path
-
-
-def _read(path: Path, workstream: str | None) -> list[dict]:
-    if not retry_denied(path.exists):
-        return []
-    text = retry_denied(lambda: path.read_text(encoding="utf-8"))
-    header, body = split_document(text)
-    name = workstream or "inbox"
-    if header.get("type") != "todo" or header.get("workstream") != name or header.get("status") not in {"current", "done"}:
-        raise ValueError(f"invalid to-do header: {path}")
-    items = []
-    for line in body.splitlines():
-        if not line.strip() or line == "# To-dos":
-            continue
-        match = _ITEM.fullmatch(line)
-        if not match:
-            raise ValueError(f"invalid to-do row: {path}")
-        data = json.loads(match.group(3))
-        if not isinstance(data, dict) or not isinstance(data.get("id"), str):
-            raise ValueError(f"invalid to-do item: {path}")
-        uuid.UUID(data["id"])
-        if "resolves" in data:
-            _resolves_path(path.parents[2], data["resolves"])
-        items.append({"id": data["id"], "title": match.group(2), "done": match.group(1) == "x",
-                      **{key: data[key] for key in ("resolves", "partial") if key in data}})
-    if len({item["id"] for item in items}) != len(items):
-        raise ValueError(f"duplicate to-do id: {path}")
-    expected = "done" if workstream not in (None, "inbox") and items and all(item["done"] for item in items) else "current"
-    if header["status"] != expected:
-        raise ValueError(f"to-do status mismatch: {path}")
-    return items
-
-
-def _write(path: Path, root: Path, workstream: str | None, items: list[dict]) -> None:
-    status = "done" if workstream not in (None, "inbox") and items and all(item["done"] for item in items) else "current"
-    lines = ["---", "type: todo", f"status: {status}", f"workstream: {workstream or 'inbox'}",
-             "---", "", "# To-dos", ""]
-    for item in items:
-        metadata = {"id": item["id"]}
-        for key in ("resolves", "partial"):
-            if key in item:
-                metadata[key] = item[key]
-        box = "x" if item["done"] else " "
-        lines.append(f'- [{box}] {item["title"]} <!-- caddis: {json.dumps(metadata, sort_keys=True)} -->')
-    atomic_write(path, "\n".join(lines) + "\n", root=root)
-
-
-def _title(value: str) -> str:
-    title = " ".join(value.split())
-    if not title or len(title) > 300 or "<!--" in title or "-->" in title:
-        raise ValueError("to-do text must be one plain line (1-300 characters)")
-    return title
+RECONCILE_RETIRED = "caddis_todo: reconcile is retired (3-store model); nothing to do"
 
 
 def _resolves_path(root: Path, value: str) -> Path:
@@ -123,58 +54,6 @@ def _resolves_path(root: Path, value: str) -> Path:
     return target
 
 
-def _suggest(root: Path, title: str) -> list[str]:
-    parking = _artifact(root) / "parking-lot"
-    if not parking.is_dir() or parking.is_symlink():
-        return []
-    words = set(_WORD.findall(title.lower()))
-    found = []
-    for path in sorted(parking.glob("*.md")):
-        if path.is_symlink() or path.name == "README.md":
-            continue
-        if words & set(_WORD.findall(path.stem.lower())) or path.name.lower() in title.lower():
-            found.append(f"parking-lot/{path.name}")
-    return found
-
-
-def add(root: Path, title: str, workstream: str | None = None, *, resolves: str | None = None,
-        partial: bool = False) -> dict:
-    title = _title(title)
-    artifact, path = _path(root, workstream)
-    if partial and not resolves:
-        raise ValueError("--partial requires --resolves")
-    linked = f"parking-lot/{_resolves_path(root, resolves).name}" if resolves else None
-    with locked_path(path, root=artifact):
-        items = _read(path, workstream)
-        item = {"id": str(uuid.uuid4()), "title": title, "done": False}
-        if linked:
-            item["resolves"] = linked
-            if partial:
-                item["partial"] = True
-        items.append(item)
-        _write(path, artifact, workstream, items)
-    return item
-
-
-def done(root: Path, item_id: str, workstream: str) -> dict:
-    artifact, path = _path(root, workstream)
-    with locked_path(path, root=artifact):
-        items = _read(path, workstream)
-        matches = [item for item in items if item["id"] == item_id]
-        if not matches:
-            raise ValueError("unknown to-do id")
-        item = matches[0]
-        if not item["done"]:
-            item["done"] = True
-            _write(path, artifact, workstream, items)
-        return item
-
-
-def list_items(root: Path, workstream: str | None = None) -> list[dict]:
-    _, path = _path(root, workstream)
-    return [item for item in _read(path, workstream) if not item["done"]]
-
-
 def _is_done(status: str) -> bool:
     """A Tracker status cell that means done: "done", "done (note)" or a leading check mark.
     A cell that says work is still pending is not done (owner decision 2026-09-27)."""
@@ -276,7 +155,7 @@ def tracker_table(text: str) -> tuple[list[str], list[str]] | None:
 
     None when there is no Tracker heading line, no `| Phase |` header or no Status column. The
     lines are every line of the section except the header; callers pick the rows they trust.
-    One reader, so the open-work view and caddis_tidy never disagree about the same table.
+    One reader, so caddis_tidy and any later caller never disagree about the same table.
     """
     # A real heading line only: plan prose may mention "## Tracker" inline before the section.
     heading = re.search(r"^## Tracker\b.*$", text, re.M)
@@ -293,235 +172,39 @@ def tracker_table(text: str) -> tuple[list[str], list[str]] | None:
     return columns, table[:at] + table[at + 1:]
 
 
-def _plan_rows(plan: Path | None) -> list[dict]:
-    if plan is None:
-        return []
-    text = plan.read_text(encoding="utf-8")
-    table = tracker_table(text)
-    if table is None:
-        return []
-    columns, lines = table
-    rows = []
-    for line in lines:
-        match = _PHASE.match(line)
-        if not match:
-            continue
-        cells = [cell.strip() for cell in line.strip("|").split("|")]
-        if len(cells) != len(columns) or _is_done(cells[columns.index("status")]):
-            continue
-        number = match.group(1)
-        heading = re.search(rf"^### Phase {number}\s+[-—]\s+(.+)$", text, re.M)
-        # Drop the heading's trailing status marker (🔲, ⏳, ✅ ...): status lives in the Tracker.
-        title = _STATUS_MARKER.sub("", heading.group(1)) if heading else f"Phase {number}"
-        rows.append({"id": f"phase:{number}", "kind": "phase", "title": title})
-    return rows
-
-
-def _split_cells(line: str) -> list[str]:
-    r"""Stripped cells of one table line, split on unescaped pipes only (`a \| b` is one cell)."""
-    parts = re.split(r"(?<!\\)\|", line.strip())
-    if parts and parts[0] == "":
-        parts.pop(0)
-    if parts and parts[-1] == "":
-        parts.pop(-1)
-    return [part.strip() for part in parts]
-
-
-def _open_work_rows(root: Path) -> list[dict]:
-    path = _artifact(root) / "open-work.md"
-    if path.is_symlink() or not path.is_file():
-        return []
-    text = path.read_text(encoding="utf-8", errors="replace")
-    header, body = split_document(text)
-    if header.get("type") != "open-work":
-        return []
-    rows: list[dict] = []
-    columns: list[str] | None = None
-    id_idx = status_idx = title_idx = 0
-    for raw_line in body.splitlines():
-        line = raw_line.strip()
-        if not line.startswith("|"):
-            columns = None
-            continue
-        cells = _split_cells(line)  # unescaped pipes only, as caddis_rows.split_cells
-        if not cells or all(c and set(c) <= set("-: ") and "-" in c for c in cells):
-            continue
-        if columns is None:
-            lowered = [c.lower() for c in cells]
-            if "id" in lowered and "status" in lowered:
-                columns = lowered
-                id_idx = columns.index("id")
-                status_idx = columns.index("status")
-                title_idx = next(
-                    (i for i, col in enumerate(columns) if col in {"task", "title", "item"}),
-                    id_idx + 1,
-                )
-            continue
-        if len(cells) != len(columns):
-            continue
-        status = cells[status_idx].strip().lower()
-        first = status.split(" ", 1)[0] if status else ""
-        if _is_done(status) or first in {"not-needed", "✓", "✔"}:
-            continue
-        row_id = cells[id_idx].replace("**", "").replace("__", "").replace("`", "").strip()
-        if not row_id:
-            continue
-        title = cells[title_idx] if title_idx < len(cells) else ""
-        rows.append({"id": row_id, "kind": "open-work", "title": title})
-    return rows
-
-
-def open_work(root: Path, workstream: str | None = None) -> list[dict]:
-    rows = _plan_rows(_active_plan(root, workstream))
-    for name in (None, workstream) if workstream and workstream != "inbox" else (None,):
-        rows.extend({"id": item["id"], "kind": "todo", "title": item["title"],
-                     **{key: item[key] for key in ("resolves", "partial") if key in item}}
-                    for item in list_items(root, name))
-    rows.extend(_open_work_rows(root))
-    return rows
-
-
-def _extract_completed_ids(text: str) -> set[str]:
-    """Open-work ids of the done rows in a session-state file's "## Tasks" table.
-
-    Only the marker session_state.py writes after a task's subject counts, as in
-    ``| 3 | done | Fix x <!-- caddis: {"id": "..."} --> |``. A UUID that merely appears in a
-    task's text is never trusted: "depends on <uuid>" must not close that other item.
-    """
-    ids: set[str] = set()
-    in_tasks = False
-    for line in text.splitlines():
-        row = line.strip()
-        if row.startswith("## "):
-            in_tasks = row == "## Tasks"
-            continue
-        if not in_tasks or not row.startswith("|") or row.startswith("|---"):
-            continue
-        cells = [cell.strip() for cell in row.strip("|").split("|")]
-        # Status is the second cell; a "|" inside the subject only shifts later cells.
-        if len(cells) < 3 or cells[1].lower() not in {"done", "completed"}:
-            continue
-        marker = re.search(r"<!--\s*caddis:\s*(\{.*?\})\s*-->\s*\|?$", row)
-        if not marker:
-            continue
-        try:
-            value = json.loads(marker.group(1)).get("id")
-        except (ValueError, AttributeError):
-            continue
-        if isinstance(value, str) and value:
-            ids.add(value.lower())
-    return ids
-
-
-def reconcile(root: Path, session_state: Path) -> list[str]:
-    """Reconcile completed task rows from session-state into todo-lists.
-
-    Marks ad-hoc todo items done by metadata ID.
-    Never edits the Tracker; phase rows are ignored.
-    """
-    if not session_state.is_file():
-        return []
-
-    text = session_state.read_text(encoding="utf-8", errors="replace")
-    completed_ids = _extract_completed_ids(text)
-    if not completed_ids:
-        return []
-
-    artifact = _artifact(root)
-    todo_dir = artifact / "todo-list"
-    if not todo_dir.is_dir():
-        return []
-
-    reconciled: list[str] = []
-    # Ignore phase rows — Tracker is never edited!
-    adhoc_ids = {cid for cid in completed_ids if not cid.startswith("phase:")}
-    if not adhoc_ids:
-        return []
-
-    wanted = {a.lower() for a in adhoc_ids}
-    for todo_file in todo_dir.glob("*.md"):
-        if todo_file.is_symlink() or not todo_file.is_file():
-            continue
-        workstream_name = todo_file.stem
-        try:
-            items = _read(todo_file, workstream_name)
-        except (ValueError, OSError):
-            continue  # a hand-edited file caddis cannot read; the others still reconcile
-        for item in items:
-            item_id = item.get("id")
-            if item_id and item_id.lower() in wanted and not item.get("done"):
-                done(root, item_id, workstream_name)
-                reconciled.append(item_id)
-
-    return reconciled
-
-
 def main(argv: list[str] | None = None) -> int:
-    # Titles carry non-ASCII text; a Windows console defaults to a legacy code page.
+    # Plan paths may carry non-ASCII text; a Windows console defaults to a legacy code page.
     for stream in (sys.stdout, sys.stderr):
         if hasattr(stream, "reconfigure"):
             stream.reconfigure(encoding="utf-8", errors="replace")
-    parser = argparse.ArgumentParser(description=__doc__)
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     parser.add_argument("--root", type=Path, default=Path.cwd(), help=argparse.SUPPRESS)
     commands = parser.add_subparsers(dest="command", required=True)
-    listing = commands.add_parser("list")
-    listing.add_argument("workstream", nargs="?")
-    adding = commands.add_parser("add")
-    adding.add_argument("text")
-    adding.add_argument("--workstream")
-    adding.add_argument("--resolves")
-    adding.add_argument("--partial", action="store_true")
-    finishing = commands.add_parser("done")
-    finishing.add_argument("id")
-    finishing.add_argument("--workstream", required=True)
-    view = commands.add_parser("open-work")
-    view.add_argument("--workstream")
-    view.add_argument("--json", action="store_true")
-    reconcile_p = commands.add_parser("reconcile")
-    reconcile_p.add_argument("--session-state", type=Path, required=True)
     commands.add_parser("active-plan")
-    args = parser.parse_args(argv)
-    try:
-        if args.command == "add":
-            item = add(args.root, args.text, args.workstream, resolves=args.resolves, partial=args.partial)
-            print(item["id"])
-            if not args.resolves:
-                for suggestion in _suggest(args.root, item["title"]):
-                    print(f"Suggested parking item: {suggestion}")
-        elif args.command == "done":
-            item = done(args.root, args.id, args.workstream)
-            if "resolves" in item:
-                prefix = "Partly-Resolves-Parked" if item.get("partial") else "Resolves-Parked"
-                print(f'{prefix}: {item["resolves"]}')
-        elif args.command == "list":
-            for item in list_items(args.root, args.workstream):
-                print(f'{item["id"]} {item["title"]}')
-        elif args.command == "active-plan":
-            plan, candidates = active_plan(args.root)
-            if plan is None:
-                if candidates:
-                    print("caddis-todo: several current plans; name one:", file=sys.stderr)
-                    for candidate in candidates:
-                        print(f"  {candidate}", file=sys.stderr)
-                else:
-                    print("caddis-todo: no current plan in .caddis/plans", file=sys.stderr)
-                return caddis_exit.NOT_RUN
-            print(plan)
-        elif args.command == "reconcile":
-            reconciled = reconcile(args.root, args.session_state)
-            for rid in reconciled:
-                print(f"Reconciled: {rid}")
-        else:
-            rows = open_work(args.root, args.workstream)
-            if args.json:
-                print(json.dumps(rows, ensure_ascii=False))
-            else:
-                for row in rows:
-                    print(f'{row["id"]} [{row["kind"]}] {row["title"]}')
+    # Retired: kept one release so an older /handoff Step 6 does not fail. Takes its old flag, ignores it.
+    reconcile_p = commands.add_parser("reconcile", help=argparse.SUPPRESS)
+    reconcile_p.add_argument("--session-state", type=Path)
+    args, extra = parser.parse_known_args(argv)
+    if extra and args.command != "reconcile":
+        parser.error(f"unrecognized arguments: {' '.join(extra)}")  # only the retired no-op tolerates old flags
+    if args.command == "reconcile":
+        print(RECONCILE_RETIRED)
         return 0
-    except (OSError, UnicodeError, ValueError, json.JSONDecodeError) as exc:
+    try:
+        plan, candidates = active_plan(args.root)
+    except (OSError, UnicodeError, ValueError) as exc:
         print(f"caddis-todo: {exc}", file=sys.stderr)
         return 1
+    if plan is None:
+        if candidates:
+            print("caddis-todo: several current plans; name one:", file=sys.stderr)
+            for candidate in candidates:
+                print(f"  {candidate}", file=sys.stderr)
+        else:
+            print("caddis-todo: no current plan in .caddis/plans", file=sys.stderr)
+        return caddis_exit.NOT_RUN
+    print(plan)
+    return 0
 
 
 if __name__ == "__main__":

package/bundles/antigravity-plugin/skills/flow-studio/README.md

@@ -3,7 +3,7 @@
 The `flow-studio` skill: a model file (JSON) describes a flow, lifecycle or journey, and one
 engine draws it as a self-contained HTML page with pan and zoom, lanes, linked nodes, a slide-in
 inspector, scenario playback, metric overlays, live update, motion that carries state, and numbered implementation notes. The design is in
-`.caddis/plans/flow-studio-skill-design.md`; the S4 stage status is in `.caddis/plans/flow-studio-s4-status.md`.
+`.caddis/plans/done/flow-studio-skill-design.md`; the S4 stage status is in `.caddis/plans/flow-studio-s4-status.md`.
 `SKILL.md` is the current playbook.
 
 ## Use it

package/bundles/antigravity-plugin/skills/handoff/SKILL.md

@@ -36,7 +36,6 @@ them into its commit, so check first, before Step 1.
    - Step 3, point 4: make the plan's Tracker edit in `<worktree>/.caddis/plans/<feature>.md`, and write
      any new parking-lot item under `<worktree>/.caddis/parking-lot/`, not in this checkout.
    - Step 4: skip `caddis_tidy.py --apply` (report `skipped: shared checkout`).
-   - Step 6: retired; nothing to skip (row 8 reports `skipped: retired (see the 3-store model)`).
    - Step 6b: skip `session_state.py prune` (report `skipped: shared checkout`).
    - Step 6c: run `--reindex` in the worktree (it edits the tracked `DOC-MAP.md`).
    - Step 6d: runs as written. It never writes a file in this checkout; it only removes worktrees and
@@ -53,27 +52,22 @@ them into its commit, so check first, before Step 1.
 
 ## Checklist
 The handoff is a fixed checklist. Every row ends as `done`, `skipped: <reason>` or `failed: <error>`, and
-Step 8 prints all 14 in this order. Never drop a row from the report, even when its step did not apply.
-Rows 3 and 8 are retired (the 3-store model, 21 Oct 2026): they stay in the list so the row numbers do not
-move for a fleet that mixes caddis versions, and each always reports
-`skipped: retired (see the 3-store model)`. A later release removes them with their scripts.
+Step 8 prints all 12 in this order. Never drop a row from the report, even when its step did not apply.
 
 | # | Row | What it is | Shared checkout (Step 0) |
 |---|---|---|---|
 | 1 | `knowledge-transfer` | Step 1 | edits only in the Step 0 worktree |
 | 2 | `plan-tracker` | the plan's Tracker row (Rules) | edit in the Step 0 worktree |
-| 3 | `open-work-row` | retired: always `skipped: retired (see the 3-store model)` | never runs |
-| 4 | `relay` | Step 3: the relay, written from scratch with current state only | the relay is local; runs |
-| 5 | `tasks-file` | Step 3c | runs |
-| 6 | `kb-index` | Step 6c: refresh the KB index | in the Step 0 worktree |
-| 7 | `violations-report` | Step 6c: report standing violations, each with a one-line fix command | runs (report only) |
-| 8 | `todo-reconcile` | retired: always `skipped: retired (see the 3-store model)` | never runs |
-| 9 | `usage-record` | Step 6b: `session_state.py usage` | runs |
-| 10 | `tidy-apply` | Step 4: `caddis_tidy.py --apply` | `skipped: shared checkout` |
-| 11 | `state-prune` | Step 6b: `session_state.py prune` | `skipped: shared checkout` |
-| 12 | `prune-list` | Step 6b: `caddis_tidy.py --prune --temp`, list only | runs (lists, never applies) |
-| 13 | `handover-check` | Step 5 | runs |
-| 14 | `own-cleanup` | Step 6d: `caddis_created.py cleanup --apply` removes this session's merged, clean worktrees and scratch folders; lists the rest with a reason | runs (only this session's recorded worktrees and scratch) |
+| 3 | `relay` | Step 3: the relay, written from scratch with current state only | the relay is local; runs |
+| 4 | `tasks-file` | Step 3c | runs |
+| 5 | `kb-index` | Step 6c: refresh the KB index | in the Step 0 worktree |
+| 6 | `violations-report` | Step 6c: report standing violations, each with a one-line fix command | runs (report only) |
+| 7 | `usage-record` | Step 6b: `session_state.py usage` | runs |
+| 8 | `tidy-apply` | Step 4: `caddis_tidy.py --apply` | `skipped: shared checkout` |
+| 9 | `state-prune` | Step 6b: `session_state.py prune` | `skipped: shared checkout` |
+| 10 | `prune-list` | Step 6b: `caddis_tidy.py --prune --temp`, list only | runs (lists, never applies) |
+| 11 | `handover-check` | Step 5 | runs |
+| 12 | `own-cleanup` | Step 6d: `caddis_created.py cleanup --apply` removes this session's merged, clean worktrees and scratch folders; lists the rest with a reason | runs (only this session's recorded worktrees and scratch) |
 
 `tidy-apply` and `state-prune` run only on `SHARED: no`. Handoff never runs
 `caddis_tidy.py --prune --apply` on its own, in any checkout (nor `--prune --temp --apply`); only the user can ask for it (Step 6b). In a
@@ -172,7 +166,6 @@ history, and the relay has a 4,000-character budget (`caddis_budget.py`).
 >      checkout (Step 0) write it in the Step 0 worktree.
 >    - **The order of work:** the plan Tracker and the roadmap (below). Set the Tracker row of each phase this
 >      session finished (Rules).
->    Row 3 (`open-work-row`) is retired: report it exactly as `skipped: retired (see the 3-store model)`.
 >    The `.caddis/open-work.md` and `.caddis/todo-list/` stores are retired. Never write them. A repo that
 >    still holds an old file keeps it as its own document; caddis no longer reads or writes it.
 >    **Order of work:** when the repo has a roadmap (`caddis_roadmap.py list` prints a slug), the
@@ -294,11 +287,6 @@ incoming session looking for a prompt that was never written. Fix what it lists,
 It also notes any generated artefact committed before its generator last changed. That is advisory,
 not blocking — but do not quote a report the note names without rebuilding it first.
 
-## Step 6 — retired (task reconcile)
-This step is retired. It used to reconcile the `todo-list/` store, which is retired too (the 3-store model),
-so the step does nothing: do not run any script for it. Report row 8 (`todo-reconcile`) as
-`skipped: retired (see the 3-store model)`. The script stays in place for older installs only.
-
 ## Step 6b — record usage and tidy session state
 The Stop hook only writes the session-state file. These two used to run on every turn; they run
 here, once:
@@ -309,7 +297,7 @@ python "${CLAUDE_PLUGIN_ROOT}/scripts/session_state.py" prune
 `usage` finds this session's transcript by its id and appends one token-and-skill record to
 `.caddis/usage-log.jsonl`, which `/usage-review` reads. Pass `--transcript <path>` if you know the
 path and it is not under the Claude config folder. `prune` keeps the newest 8 files in
-`.caddis/session-state/`; run it after Step 6, which reads this session's file. Skip `prune` in a
+`.caddis/session-state/`; run it after Step 3c, which reads this session's file. Skip `prune` in a
 shared checkout (Step 0). Include the
 `[USAGE]` line in your output. Both always exit 0; if the script is missing, skip this step.
 
@@ -328,12 +316,12 @@ yourself**; deleting is the user's choice. If they ask, run `--prune --temp --ap
 Both scripts fall back to `claude-harness/scripts/check_doc_coverage.py` and `scripts/caddis_tidy.py` in a
 source checkout; a script that is missing is `skipped: <script> not installed`.
 
-Checklist row 6, `kb-index` (in a shared checkout, run it in the Step 0 worktree, before the Step 0
+Checklist row 5, `kb-index` (in a shared checkout, run it in the Step 0 worktree, before the Step 0
 `finish`; it edits `DOC-MAP.md`):
 ```
 python "${CLAUDE_PLUGIN_ROOT}/scripts/check_doc_coverage.py" --reindex
 ```
-Checklist row 7, `violations-report` (all three only report; never fix files here):
+Checklist row 6, `violations-report` (all three only report; never fix files here):
 ```
 python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_tidy.py" --check
 python "${CLAUDE_PLUGIN_ROOT}/scripts/check_doc_coverage.py"
@@ -353,7 +341,7 @@ python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_roadmap.py" render --all
 ```
 
 ## Step 6d — remove this session's own worktrees and scratch folders
-Checklist row 14, `own-cleanup`. It runs in every checkout, a shared one too, after the Step 0 `finish`
+Checklist row 12, `own-cleanup`. It runs in every checkout, a shared one too, after the Step 0 `finish`
 (falls back to `scripts/caddis_created.py` in a source checkout; if the script is missing, or exits 2 because
 it has no `cleanup`, the row is `skipped: not installed`):
 ```
@@ -392,18 +380,16 @@ Print this block, every row filled with `done`, `skipped: <reason>` or `failed:
 === HANDOFF CHECKLIST ===
 1 knowledge-transfer   done | skipped: <reason> | failed: <error>
 2 plan-tracker         <same three forms>
-3 open-work-row        skipped: retired (see the 3-store model)
-4 relay                <same three forms>
-5 tasks-file           <same three forms>
-6 kb-index             <same three forms>
-7 violations-report    <same three forms>
-8 todo-reconcile       skipped: retired (see the 3-store model)
-9 usage-record         <same three forms>
-10 tidy-apply          <same three forms>
-11 state-prune         <same three forms>
-12 prune-list          <same three forms>
-13 handover-check      <same three forms>
-14 own-cleanup         <same three forms>
+3 relay                <same three forms>
+4 tasks-file           <same three forms>
+5 kb-index             <same three forms>
+6 violations-report    <same three forms>
+7 usage-record         <same three forms>
+8 tidy-apply           <same three forms>
+9 state-prune          <same three forms>
+10 prune-list          <same three forms>
+11 handover-check      <same three forms>
+12 own-cleanup         <same three forms>
 Shared checkout: yes|no <reason>
 ```
 

package/bundles/antigravity-plugin/warm_start_agy.py

@@ -351,11 +351,10 @@ def main() -> None:
         conversation = str(data.get("conversationId") or "").strip()
 
         blocks = []
-        open_work_blocks = []
         for root in roots:
             if conversation and _already_injected(root, conversation):
                 continue
-            relay, matched_ws = resolve_relay(root, conversation)
+            relay, _ws = resolve_relay(root, conversation)
             text = ""
             if relay:
                 try:
@@ -370,41 +369,7 @@ def main() -> None:
                     blocks.append("relay for " + os.path.basename(root.rstrip("/\\")) + ":")
                 blocks.append(truncate_relay(text))
 
-            # Open-work rows as plain text without seeding instruction. Shown with or without a
-            # relay: to-dos and plan phases exist before the first handoff writes one.
-            shown_open_work = False
-            try:
-                from pathlib import Path as _Path
-                # agy plugin: warm_start_agy.py sits at the plugin root, scripts in <plugin>/scripts.
-                # Source tree: claude-harness/agy -> <repo>/scripts, where caddis_todo.py is authored.
-                _here = os.path.dirname(os.path.abspath(__file__))
-                for _sc in (os.path.join(os.path.dirname(os.path.dirname(_here)), "scripts"),
-                            os.path.join(_here, "scripts")):
-                    if os.path.isdir(_sc) and _sc not in sys.path:
-                        sys.path.insert(0, _sc)
-                import caddis_todo
-                open_items = caddis_todo.open_work(_Path(root), matched_ws)
-                if open_items:
-                    # Same budget as the Claude Code hook: next 5 phases, 5 ad-hoc items.
-                    phases = [r for r in open_items if r.get("kind") == "phase"][:5]
-                    todos = [r for r in open_items if r.get("kind") != "phase"][:5]
-                    shown = phases + todos
-                    ow_lines = ["## Open work"]
-                    if len(open_items) > len(shown):
-                        ow_lines.append(f"(+{len(open_items) - len(shown)} more open items — run /catchup to see them.)")
-                    for row in shown:
-                        ow_lines.append(f"- {row['id']} [{row['kind']}] {' '.join(str(row['title']).split())[:100]}")
-                    if len(roots) > 1:
-                        open_work_blocks.append("open work for " + os.path.basename(root.rstrip("/\\")) + ":\n" + "\n".join(ow_lines))
-                    else:
-                        open_work_blocks.append("\n".join(ow_lines))
-                    shown_open_work = True
-            except Exception as _exc:
-                _hook_note("agy open work injection", _exc, root)
-
-            # A relay that exists but failed to read must not be marked injected just because
-            # open work was shown: the next invocation retries the relay.
-            if conversation and (text or (not relay and shown_open_work)):
+            if conversation and text:
                 _mark_injected(root, conversation)
 
         # agy has no SessionStart event, so this first invocation is also where the freshness
@@ -414,14 +379,12 @@ def main() -> None:
         for root in roots:
             fresh.extend(freshness_lines(root))
 
-        if not blocks and not fresh and not open_work_blocks:
+        if not blocks and not fresh:
             return
         parts = []
         if blocks:
             parts.append(RELAY_FRAME_HEADER + "\n" + "\n\n".join(blocks)
                          + "\n\n" + RELAY_FRAME_FOOTER)
-        if open_work_blocks:
-            parts.append("\n\n".join(open_work_blocks))
         if fresh:
             parts.append("\n".join(fresh))
         payload = json.dumps({"injectSteps": [{"ephemeralMessage": "\n\n".join(parts)}]})

package/bundles/codex/.codex/skills/frontend/flow-studio/README.md

@@ -3,7 +3,7 @@
 The `flow-studio` skill: a model file (JSON) describes a flow, lifecycle or journey, and one
 engine draws it as a self-contained HTML page with pan and zoom, lanes, linked nodes, a slide-in
 inspector, scenario playback, metric overlays, live update, motion that carries state, and numbered implementation notes. The design is in
-`.caddis/plans/flow-studio-skill-design.md`; the S4 stage status is in `.caddis/plans/flow-studio-s4-status.md`.
+`.caddis/plans/done/flow-studio-skill-design.md`; the S4 stage status is in `.caddis/plans/flow-studio-s4-status.md`.
 `SKILL.md` is the current playbook.
 
 ## Use it

package/bundles/manifest.json

@@ -1,7 +1,7 @@
 {
-  "poolVersion": "1.3.155",
+  "poolVersion": "1.3.156",
   "bundles": {
-    "antigravity-plugin": "1.3.155",
+    "antigravity-plugin": "1.3.156",
     "antigravity-plugin-extras": "1.3.46",
     "codex": "unknown"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caddis/cli",
-  "version": "0.4.69",
+  "version": "0.4.70",
   "description": "Install, update and diagnose the caddis dev harness across every coding agent you use (Claude Code, agy/Antigravity, and more).",
   "keywords": [
     "caddis",