vibe-coding-master 0.7.39 → 0.7.41

package/scripts/harness-tools/vcm-bash-guard

@@ -2,8 +2,7 @@
 """VCM PreToolUse guard for supervised tools inside VCM role sessions.
 
 Reads the Claude Code PreToolUse hook payload on stdin. It enforces supervised
-Bash execution for every VCM role and prevents LSP-enabled roles from replacing
-semantic code navigation with the Grep tool or shell text-search commands.
+Bash execution for every VCM role.
 
 Quoted payloads of `sh -c` / `bash -lc` style invocations are executable
 shell code, so they are scanned recursively. `.ai/tools/run-long-check` is the
@@ -11,7 +10,6 @@ only sanctioned detached worker; the command it runs must still stay in the
 supervised foreground process group.
 """
 import json
-import os
 import re
 import sys
 
@@ -21,12 +19,11 @@ SKILL_HINT = (
     "`.ai/tools/watch-job <job-id>` in the same turn, repeating watch-job "
     "until it reports a terminal result."
 )
-CODE_NAV_HINT = (
-    "Use LSP, Glob, Read, generated context, architecture documents, or runtime "
-    "evidence; do not substitute text search."
+ARTIFACT_HINT = (
+    "VCM-managed Markdown cannot be written directly. Write a candidate outside "
+    ".ai/vcm, then run .ai/tools/vcm-artifact <kind> --file <candidate> "
+    "--mode <draft|final>."
 )
-LSP_ROLES = {"architect", "coder", "reviewer"}
-
 MAX_NESTED_SHELL_DEPTH = 3
 QUOTED = re.compile(r"'([^']*)'|\"([^\"]*)\"")
 SHELL_DASH_C = re.compile(r"(?:^|[\s;&|(])(?:sh|bash|zsh|dash|ksh)\s+(?:-\w+\s+)*-\w*c\w*(?:\s|$)")
@@ -44,22 +41,20 @@ RUN_LONG_CHECK_SHELL_STRING = re.compile(
     r"(?:-\w+\s+)*-\w*c\w*(?:\s|$)"
 )
 COMMAND_SUBSTITUTION = re.compile(r"\$\(([^()]*)\)|`([^`]*)`")
-TEXT_SEARCH_COMMAND = re.compile(
-    r"(?:^|[;&|()\n`])\s*"
-    r"(?:(?:[A-Za-z_][A-Za-z0-9_]*=[^\s;&|()]+)\s+)*"
-    r"(?:env(?:\s+(?:-[^\s]+|[A-Za-z_][A-Za-z0-9_]*=[^\s]+))*\s+)?"
-    r"(?:command\s+|sudo(?:\s+-[^\s]+)*\s+)?"
-    r"(?:[^\s;&|()]*/)?(?:grep|egrep|fgrep|rg|ripgrep)(?=\s|$|[;&|()])"
-)
-GIT_GREP_COMMAND = re.compile(
-    r"(?:^|[;&|()\n`])\s*(?:git)(?:\s+-[^\s]+)*\s+grep(?=\s|$|[;&|()])"
+MANAGED_ARTIFACT_PATH = re.compile(
+    r"(?:^|[\s/\\])\.ai[/\\]vcm[/\\](?:"
+    r"handoffs[/\\].*\.md|"
+    r"gate-reviews[/\\]requests[/\\].*\.report\.md|"
+    r"memory-review[/\\].*\.md|"
+    r"coder-workers[/\\]reports[/\\].*\.md|"
+    r"harness-feedback[/\\](?:pending|task-retrospectives)[/\\].*\.md"
+    r")"
 )
-WRAPPED_TEXT_SEARCH_COMMAND = re.compile(
-    r"(?:^|\s)(?:xargs(?:\s+-[^\s]+)*|-exec|-execdir)\s+"
-    r"(?:[^\s;&|()]*/)?(?:grep|egrep|fgrep|rg|ripgrep)(?=\s|$|[;&|()])"
+SHELL_WRITE = re.compile(
+    r"(?:>>?|\btee\b|\brm\b|\bmv\b|\bcp\b|"
+    r"\bsed\b[^\n]*\s-i\b|\bperl\b[^\n]*\s-i\b|"
+    r"\bpython\d*\b|\bnode\b)"
 )
-
-
 def strip_quoted(command: str) -> str:
     return QUOTED.sub(" ", command)
 
@@ -101,7 +96,7 @@ def protected_tool_invoked(command_without_quotes: str) -> bool:
     return bool(PROTECTED_TOOL_INVOCATION.search(command_without_quotes))
 
 
-def scan_shell_command(command: str, depth: int = 0, forbid_text_search: bool = False) -> list[str]:
+def scan_shell_command(command: str, depth: int = 0) -> list[str]:
     reasons = []
     stripped = strip_escaped_characters(strip_quoted(command))
     if re.search(r"(?:^|[\s;&|(])(?:nohup|setsid)(?:\s|$)", stripped):
@@ -110,13 +105,6 @@ def scan_shell_command(command: str, depth: int = 0, forbid_text_search: bool =
         reasons.append("disown is forbidden")
     if unquoted_ampersand(stripped):
         reasons.append("'&' background execution is forbidden")
-    if forbid_text_search and (
-        TEXT_SEARCH_COMMAND.search(stripped)
-        or GIT_GREP_COMMAND.search(stripped)
-        or WRAPPED_TEXT_SEARCH_COMMAND.search(stripped)
-    ):
-        reasons.append("text-search commands are forbidden for this LSP-enabled role")
-
     if protected_tool_invoked(stripped):
         if SHELL_CONTROL_OPERATOR.search(stripped):
             reasons.append("run-long-check and watch-job must be standalone Bash commands")
@@ -128,17 +116,17 @@ def scan_shell_command(command: str, depth: int = 0, forbid_text_search: bool =
         for segment in quoted_segments(command):
             if protected_tool_invoked(strip_escaped_characters(strip_quoted(segment))):
                 reasons.append("run-long-check and watch-job must not be invoked through a shell command string")
-            reasons.extend(scan_shell_command(segment, depth + 1, forbid_text_search))
+            reasons.extend(scan_shell_command(segment, depth + 1))
     if depth < MAX_NESTED_SHELL_DEPTH:
         for substitution in double_quoted_command_substitutions(command):
             nested_stripped = strip_escaped_characters(strip_quoted(substitution))
             if protected_tool_invoked(nested_stripped):
                 reasons.append("run-long-check and watch-job must not be invoked through command substitution")
-            reasons.extend(scan_shell_command(substitution, depth + 1, forbid_text_search))
+            reasons.extend(scan_shell_command(substitution, depth + 1))
     return reasons
 
 
-def guard_reasons(tool_input: dict, forbid_text_search: bool = False) -> list[str]:
+def guard_reasons(tool_input: dict) -> list[str]:
     reasons = []
     if tool_input.get("run_in_background"):
         reasons.append("Bash run_in_background is forbidden")
@@ -146,7 +134,14 @@ def guard_reasons(tool_input: dict, forbid_text_search: bool = False) -> list[st
     command = tool_input.get("command")
     command = command if isinstance(command, str) else ""
 
-    reasons.extend(scan_shell_command(command, forbid_text_search=forbid_text_search))
+    reasons.extend(scan_shell_command(command))
+    unquoted_path_command = command.replace('"', "").replace("'", "")
+    if (
+        MANAGED_ARTIFACT_PATH.search(unquoted_path_command)
+        and "vcm-artifact" not in command
+        and SHELL_WRITE.search(strip_quoted(command))
+    ):
+        reasons.append("direct Bash writes to VCM-managed Markdown are forbidden")
     return list(dict.fromkeys(reasons))
 
 
@@ -157,25 +152,24 @@ def main() -> int:
     except ValueError:
         return 0
     tool_name = payload.get("tool_name")
-    role = os.environ.get("VCM_ROLE", "").strip()
-    forbid_text_search = role in LSP_ROLES
-    if tool_name == "Grep" and forbid_text_search:
-        reasons = ["the Grep tool is forbidden for this LSP-enabled role"]
-    elif tool_name == "Bash":
+    if tool_name == "Bash":
+        tool_input = payload.get("tool_input")
+        tool_input = tool_input if isinstance(tool_input, dict) else {}
+        reasons = guard_reasons(tool_input)
+    elif tool_name in ("Write", "Edit"):
         tool_input = payload.get("tool_input")
         tool_input = tool_input if isinstance(tool_input, dict) else {}
-        reasons = guard_reasons(tool_input, forbid_text_search=forbid_text_search)
+        file_path = tool_input.get("file_path") or tool_input.get("path")
+        reasons = (
+            ["direct Write/Edit of VCM-managed Markdown is forbidden"]
+            if isinstance(file_path, str) and MANAGED_ARTIFACT_PATH.search(file_path)
+            else []
+        )
     else:
         return 0
     if not reasons:
         return 0
 
-    hints = []
-    if any("text-search" in reason or "Grep tool" in reason for reason in reasons):
-        hints.append(CODE_NAV_HINT)
-    if any("text-search" not in reason and "Grep tool" not in reason for reason in reasons):
-        hints.append(SKILL_HINT)
-
     print(
         json.dumps(
             {
@@ -183,7 +177,8 @@ def main() -> int:
                     "hookEventName": "PreToolUse",
                     "permissionDecision": "deny",
                     "permissionDecisionReason": (
-                        "VCM denied this tool call (" + "; ".join(reasons) + "). " + " ".join(hints)
+                        "VCM denied this tool call (" + "; ".join(reasons) + "). "
+                        + (ARTIFACT_HINT if any("Markdown" in reason for reason in reasons) else SKILL_HINT)
                     ),
                 }
             }

package/scripts/harness-tools/watch-job

@@ -6,8 +6,9 @@ Usage:
 
 watch-job renews the job supervision lease while it runs. When the watch
 window elapses and the job is still running, it exits 125 WITHOUT stopping
-the job; call watch-job again immediately in the same turn. The job ceiling
-itself is enforced by the run-long-check worker, not by watch-job.
+the job and grants a bounded handoff for the next watcher; call watch-job
+again immediately in the same turn. The job ceiling itself is enforced by
+the run-long-check worker, not by watch-job.
 
 Exit codes:
   0    success
@@ -19,13 +20,16 @@ Exit codes:
 """
 import argparse
 import json
+import os
 import sys
 import time
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
 MAX_WINDOW_SECONDS = 8 * 60
 DEFAULT_WINDOW = "8m"
 STATUS_WAIT_SECONDS = 10
+DEFAULT_NEXT_WATCH_HANDOFF_GRACE_SECONDS = 5 * 60
 TERMINAL_EXIT_CODES = {
     "success": 0,
     "failed": 1,
@@ -59,6 +63,42 @@ def read_optional_json(path: Path) -> dict | None:
         return None
 
 
+def write_json(path: Path, data: dict) -> None:
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n")
+    tmp.replace(path)
+
+
+def env_seconds(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if not raw:
+        return default
+    try:
+        return max(1.0, float(raw))
+    except ValueError:
+        return default
+
+
+def clear_handoff(handoff_path: Path) -> None:
+    try:
+        handoff_path.unlink()
+    except FileNotFoundError:
+        pass
+
+
+def begin_handoff(handoff_path: Path, grace_seconds: float) -> str:
+    now = datetime.now(timezone.utc)
+    due_at = (now + timedelta(seconds=grace_seconds)).isoformat().replace("+00:00", "Z")
+    write_json(
+        handoff_path,
+        {
+            "createdAt": now.isoformat().replace("+00:00", "Z"),
+            "nextWatchDueAt": due_at,
+        },
+    )
+    return due_at
+
+
 def renew_lease(lease_path: Path) -> None:
     try:
         lease_path.touch()
@@ -105,6 +145,9 @@ def print_summary(job_id: str, status: dict, directory: Path) -> None:
         print(f"processStopResult: {status.get('processStopResult')}")
     if state == "orphaned":
         print(f"orphanReason: {status.get('orphanReason')}")
+        print(f"lastWatchedAt: {status.get('lastWatchedAt')}")
+        if status.get("nextWatchDueAt"):
+            print(f"nextWatchDueAt: {status.get('nextWatchDueAt')}")
         print(f"processStopResult: {status.get('processStopResult')}")
     if state == "stale":
         print(f"staleReason: {status.get('staleReason')}")
@@ -120,7 +163,7 @@ def print_summary(job_id: str, status: dict, directory: Path) -> None:
             print(stderr_tail)
 
 
-def print_progress(job_id: str, status: dict, directory: Path, window: float) -> None:
+def print_progress(job_id: str, status: dict, directory: Path, window: float, next_watch_due_at: str) -> None:
     print(f"job: {job_id}")
     print("status: still-running")
     print(f"jobStatus: {status.get('status')}")
@@ -131,6 +174,7 @@ def print_progress(job_id: str, status: dict, directory: Path, window: float) ->
         if isinstance(ceiling, (int, float)):
             print(f"ceilingRemainingSeconds: {max(0, round(ceiling - elapsed))}")
     print(f"watchWindowSeconds: {int(window)}")
+    print(f"nextWatchDueAt: {next_watch_due_at}")
     stdout_tail = tail(directory / "stdout.log", lines=5)
     if stdout_tail:
         print("\nstdout tail:")
@@ -173,6 +217,11 @@ def main() -> int:
     directory = root_dir() / ".ai/vcm/jobs" / args.job_id
     status_path = directory / "status.json"
     lease_path = directory / "lease"
+    handoff_path = directory / "watch-handoff.json"
+    handoff_grace = env_seconds(
+        "VCM_JOB_NEXT_WATCH_HANDOFF_GRACE_SECONDS",
+        DEFAULT_NEXT_WATCH_HANDOFF_GRACE_SECONDS,
+    )
 
     found_deadline = time.time() + STATUS_WAIT_SECONDS
     while not status_path.is_file():
@@ -181,6 +230,9 @@ def main() -> int:
             return 2
         time.sleep(0.2)
 
+    renew_lease(lease_path)
+    clear_handoff(handoff_path)
+
     deadline = time.time() + window
     last_status: dict = {}
     while True:
@@ -190,11 +242,13 @@ def main() -> int:
             last_status = status
             state = status.get("status")
             if state in TERMINAL_EXIT_CODES:
+                clear_handoff(handoff_path)
                 print_summary(args.job_id, status, directory)
                 return TERMINAL_EXIT_CODES[state]
 
         if time.time() >= deadline:
-            print_progress(args.job_id, last_status, directory, window)
+            next_watch_due_at = begin_handoff(handoff_path, handoff_grace)
+            print_progress(args.job_id, last_status, directory, window, next_watch_due_at)
             return 125
 
         time.sleep(interval)