@xenonbyte/req-2-plan 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xenonbyte/req-2-plan",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Requirement-to-PLAN workflow CLI and agent integration installer.",
   "bin": {
     "r2p": "bin/r2p.js"

package/tools/workflow_cli/cli.py

@@ -49,9 +49,13 @@ from tools.workflow_cli.gates import (
     check_execution_complete,
 )
 from tools.workflow_cli.output import (
+    COMPACT_DETAIL_LIMIT,
+    COMPACT_FILE_LIST_LIMIT,
+    compact_human_list,
     format_success,
     format_error,
     format_gate_result,
+    is_json_mode,
     print_and_exit,
     EXIT_OK,
     EXIT_CLI_ERR,
@@ -84,10 +88,7 @@ def _load_run(work_id: str, base_path: Path | None = None):
     no command — read-only or mutating — ever follows `.req-to-plan` or
     `.req-to-plan/<id>` out of the workspace.
     """
-    root = base_path or Path.cwd()
-    _reject_symlink_or_exit(root / ".req-to-plan", "unsafe_workspace_dir_symlink")
-    run_dir = _get_run_dir(work_id, base_path)
-    _reject_symlink_or_exit(run_dir, f"Run directory is a symlink: {run_dir}")
+    run_dir = _reject_symlinked_run_paths(work_id, base_path)
     mgr = RunStateManager(run_dir)
     try:
         return mgr.load(), mgr, run_dir
@@ -98,6 +99,53 @@ def _load_run(work_id: str, base_path: Path | None = None):
         )
 
 
+def _write_recovery_list(run_dir: Path, work_id: str, filename: str, items: list[str]) -> str | None:
+    logs_dir = run_dir / "logs"
+    if logs_dir.is_symlink():
+        return None
+    try:
+        logs_dir.mkdir(parents=True, exist_ok=True)
+        recovery_path = logs_dir / filename
+        atomic_write_text(recovery_path, "\n".join(items) + "\n")
+    except OSError:
+        return None
+    return f".req-to-plan/{work_id}/logs/{filename}"
+
+
+def _human_list_payload(
+    *,
+    run_dir: Path,
+    work_id: str,
+    label: str,
+    items: list,
+    limit: int,
+    recovery_filename: str,
+    recovery_items: list[str] | None = None,
+) -> dict:
+    if is_json_mode() or len(items) <= limit:
+        return {label: items}
+
+    recovery_path = _write_recovery_list(
+        run_dir,
+        work_id,
+        recovery_filename,
+        recovery_items if recovery_items is not None else [str(item) for item in items],
+    )
+    if recovery_path is None:
+        return {label: items}
+
+    payload = compact_human_list(
+        label=label,
+        items=items,
+        limit=limit,
+        recovery_path=recovery_path,
+    )
+    payload[f"{label}_summary"] = (
+        f"{payload[f'{label}_shown']} shown, {payload[f'{label}_total']} total"
+    )
+    return payload
+
+
 def _validate_work_id(raw: str) -> WorkId:
     """Parse WorkId or exit with CLI error."""
     try:
@@ -118,6 +166,20 @@ def _reject_symlink_or_exit(path: Path, message: str) -> None:
         print_and_exit(format_error(message, exit_code=EXIT_CONFLICT), EXIT_CONFLICT)
 
 
+def _reject_symlinked_run_paths(work_id, base_path: Path | None) -> Path:
+    """Reject a symlinked workspace or run directory, then return the run dir.
+
+    Guards `.req-to-plan` and `.req-to-plan/<id>` up front (EXIT_CONFLICT) so no
+    command — read-only or mutating — ever follows either out of the workspace.
+    Call before any filesystem mutation that targets the run dir.
+    """
+    root = base_path or Path.cwd()
+    _reject_symlink_or_exit(root / ".req-to-plan", "unsafe_workspace_dir_symlink")
+    run_dir = _get_run_dir(work_id, base_path)
+    _reject_symlink_or_exit(run_dir, f"Run directory is a symlink: {run_dir}")
+    return run_dir
+
+
 def _validate_repo_path(raw: str) -> Path:
     """Return a repo path only when it is an existing directory."""
     repo_path = Path(raw)
@@ -223,7 +285,7 @@ def _cmd_run_start(args):
             EXIT_CLI_ERR,
         )
     repo_path = _validate_repo_path(args.repo_path) if args.repo_path else None
-    run_dir = _get_run_dir(work_id, args.base_path)
+    run_dir = _reject_symlinked_run_paths(work_id, args.base_path)
     mgr = RunStateManager(run_dir)
 
     run_dir_occupied = False
@@ -323,6 +385,15 @@ def _cmd_run_start(args):
 def _cmd_run_resume(args):
     record, mgr, run_dir = _load_run(args.work_id, args.base_path)
     rc = record.resume_context
+    reread_targets = list(rc.required_reread_targets)
+    reread_payload = _human_list_payload(
+        run_dir=run_dir,
+        work_id=str(record.work_id),
+        label="required_reread_targets",
+        items=reread_targets,
+        limit=COMPACT_FILE_LIST_LIMIT,
+        recovery_filename="run-resume-reread-targets.txt",
+    )
     print_and_exit(
         format_success(
             {
@@ -333,6 +404,7 @@ def _cmd_run_resume(args):
                 "next_operation": rc.next_allowed_operation,
                 "active_item": rc.active_item,
                 "resume_reason": rc.resume_reason,
+                **reread_payload,
             },
             message="Resume context",
         ),
@@ -1212,6 +1284,22 @@ def _cmd_status_run(args):
         for s in record.stale_artifacts
     ]
     outstanding_stale = [aa.stage.value for aa in record.active_artifacts if aa.status == "stale"]
+    approved_checkpoints = [cp.stage.value for cp in record.approved_checkpoints]
+    approved_payload = _human_list_payload(
+        run_dir=run_dir,
+        work_id=str(record.work_id),
+        label="approved_checkpoints",
+        items=approved_checkpoints,
+        limit=COMPACT_DETAIL_LIMIT,
+        recovery_filename="status-run-approved-checkpoints.txt",
+        recovery_items=[
+            (
+                f"{cp.stage.value}\t{cp.artifact}\tv{cp.version}\t"
+                f"{cp.approved_at}\t{cp.downstream_authorization}\t{cp.bundle_id or ''}"
+            )
+            for cp in record.approved_checkpoints
+        ],
+    )
 
     print_and_exit(
         format_success(
@@ -1226,7 +1314,7 @@ def _cmd_status_run(args):
                 "open_routes_detail": open_routes_detail,
                 "stale_artifacts": stale_artifacts,
                 "outstanding_stale": outstanding_stale,
-                "approved_checkpoints": [cp.stage.value for cp in record.approved_checkpoints],
+                **approved_payload,
             },
             message="Run status",
         ),
@@ -2000,7 +2088,7 @@ def _cmd_context_build(args):
     from tools.workflow_cli.context_pack import build_context_pack, write_context_pack
 
     work_id = str(_validate_work_id(args.work_id))
-    run_dir = _get_run_dir(work_id, args.base_path)
+    run_dir = _reject_symlinked_run_paths(work_id, args.base_path)
     if not run_dir.exists():
         print_and_exit(
             format_error(f"run not found: {work_id}", exit_code=EXIT_NOT_FOUND),

package/tools/workflow_cli/output.py

@@ -11,12 +11,38 @@ EXIT_REVIEW_REQ = 5  # forced subagent review required
 EXIT_CONFLICT = 6  # state conflict (run already closed, etc.)
 EXIT_NOT_FOUND = 7 # resource not found (run.md, artifact, etc.)
 
+# Opt-in compact display limits. Default formatters remain uncapped.
+COMPACT_DETAIL_LIMIT = 10
+COMPACT_FILE_LIST_LIMIT = 15
+
 
 def is_json_mode() -> bool:
     """Check if JSON output mode is enabled via R2P_JSON environment variable."""
     return os.environ.get("R2P_JSON", "0") == "1"
 
 
+def compact_human_list(
+    *,
+    label: str,
+    items: list,
+    limit: int,
+    recovery_path: str | None = None,
+) -> dict:
+    """Build an opt-in compact list payload without touching the filesystem."""
+    if limit < 0:
+        raise ValueError("limit must be non-negative")
+
+    visible_items = list(items[:limit])
+    result = {
+        label: visible_items,
+        f"{label}_shown": len(visible_items),
+        f"{label}_total": len(items),
+    }
+    if recovery_path:
+        result[f"{label}_full_list"] = recovery_path
+    return result
+
+
 def format_success(data: dict, message: str = "") -> str:
     """Format a success response."""
     if is_json_mode():

package/tools/workflow_cli/version.py

@@ -1 +1 @@
-R2P_VERSION = "0.5.0"
+R2P_VERSION = "0.5.2"

package/tools/workflow_cli/workspace.py

@@ -14,7 +14,7 @@ from pathlib import Path
 
 from tools.workflow_cli.atomic import atomic_write_text
 
-_WORKSPACE_GITIGNORE_LINES = ("/archive", "/.workflow-active")
+_WORKSPACE_GITIGNORE_LINES = ("/archive", "/.workflow-active", "/*/logs/")
 
 
 def ensure_workspace_gitignore(base_path: Path) -> None: