okstra 0.164.0 → 0.165.0

package/runtime/python/okstra_ctl/wizard.py

@@ -101,8 +101,8 @@ from okstra_ctl.stage_map import (
     stage_map_records,
 )
 from okstra_ctl.user_response import (
-    UserResponseApprovalRecord,
-    parse_user_response_approval,
+    PlanDecisionRecord,
+    parse_plan_decision,
 )
 from okstra_ctl.workers import (
     ALLOWED_WORKERS,
@@ -682,23 +682,27 @@ def _approve_plan_in_place(plan_path: Path) -> None:
 
 def _find_html_approval_sidecar(
     plan_path: Path,
-) -> Optional[tuple[Path, UserResponseApprovalRecord]]:
-    """plan 의 run 디렉토리 sibling ``user-responses/`` 에서 APPROVAL 블록을
-    가진 sidecar 를 찾는다. source-report 파일명과 seq 가 plan 과 일치해야
-    하며, 복수면 mtime 최신을 택한다."""
+) -> Optional[tuple[Path, PlanDecisionRecord]]:
+    """plan 의 run 디렉토리 sibling ``user-responses/`` 에서 승인 판정을 담은
+    sidecar 를 찾는다. source-report 파일명과 seq 가 plan 과 일치해야 하며,
+    복수면 mtime 최신을 택한다.
+
+    승인이 아닌 판정(반려·재작업 요청)은 여기서 걸러진다 — 이 단계가 묻는 것은
+    "사용자가 이 plan 을 승인해 두었는가" 뿐이고, 반려 사유는 다음 planning
+    run 이 sidecar 를 통째로 읽어 처리한다."""
     responses_dir = plan_path.parent.parent / "user-responses"
     if not responses_dir.is_dir():
         return None
     m = re.search(r"-(\d+)\.md$", plan_path.name)
     plan_seq = m.group(1) if m else ""
-    best: Optional[tuple[float, Path, UserResponseApprovalRecord]] = None
+    best: Optional[tuple[float, Path, PlanDecisionRecord]] = None
     for f in sorted(responses_dir.glob("user-response-*.md")):
         try:
             text = f.read_text(encoding="utf-8", errors="replace")
         except OSError:
             continue
-        rec = parse_user_response_approval(text)
-        if rec is None or rec.seq != plan_seq:
+        rec = parse_plan_decision(text)
+        if rec is None or not rec.approved or rec.seq != plan_seq:
             continue
         if Path(rec.source_report).name != plan_path.name:
             continue

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -81,6 +81,13 @@ def resolve_prompt_plan(
         raise ValueError("worker ID is required")
     if dispatch_kind.startswith("reverify-r"):
         return _plan("reverify")
+    # A critic pass keeps the full analysis contract — worker anchor headers, the
+    # audit sidecar, the packet boundary — but is exempt from the equality group.
+    # Its body is deliberately unlike the initial one (it asks for coverage gaps
+    # and unrequested work, not findings), so grouping it with the initial
+    # analysis prompts makes `validate_analysis_prompt_set` compare two prompts
+    # that are *supposed* to differ and fail every critic-enabled run.
+    analysis_equality_group = None if dispatch_kind == "critic" else "analysis-core"
     if task_type == "implementation" and not executor_worker_id:
         raise ValueError("implementation executor worker ID is required")
     if worker_id == "report-writer":
@@ -101,7 +108,7 @@ def resolve_prompt_plan(
     if task_type == "final-verification":
         return _plan(
             "analysis",
-            equality_group="analysis-core",
+            equality_group=analysis_equality_group,
             packet_only=True,
             required_headers=FINAL_VERIFICATION_HEADERS,
             max_body_lines=96,
@@ -110,11 +117,11 @@ def resolve_prompt_plan(
     if task_type == "improvement-discovery":
         return _plan(
             "analysis",
-            equality_group="analysis-core",
+            equality_group=analysis_equality_group,
             packet_only=True,
             required_headers=(GRILLING_LOG_HEADER,),
         )
-    return _plan("analysis", equality_group="analysis-core", packet_only=True)
+    return _plan("analysis", equality_group=analysis_equality_group, packet_only=True)
 
 
 def resolve_prompt_plan_for_manifest(

package/runtime/python/okstra_ctl/worker_request.py

@@ -0,0 +1,140 @@
+"""Assemble the request every provider strategy then takes on trust.
+
+A strategy translates a ``WorkerExecRequest`` into its CLI's syntax and nothing
+more: it does not resolve paths, does not decide what may be written, and does
+not know which role it is running. Whoever builds the request answers all
+three, so the answers live here — importable — rather than inside a dispatch
+entrypoint where the next caller would have to copy them.
+"""
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+
+from .domain.worker_exec import ExecutionPolicy, WorkerExecRequest
+from .domain.worker_role import role_spec
+
+# Carried over from the codex wrapper, where it was one provider's rule: cargo's
+# package-cache flock and its registry live outside every workspace, so a
+# verifier bounded to the tree alone fails each `cargo build/test/clippy` on the
+# global lock. The rule follows the role rather than the provider now — every
+# provider's verifier receives these — so the name no longer says codex. Set it
+# to a colon-separated list of absolute paths to override, or to empty to
+# disable.
+VERIFIER_EXTRA_DIRS_ENV = "OKSTRA_VERIFIER_EXTRA_DIRS"
+
+_VERIFIER_ROLE = "verifier"
+
+
+def build_request(
+    *,
+    prompt_text: str,
+    model: str,
+    project_root: Path,
+    worktree_path: Path | None,
+    role: str,
+    idle_timeout_seconds: int,
+) -> WorkerExecRequest:
+    """One dispatch, with every value the strategies will not re-derive.
+
+    Paths are resolved here because nothing downstream resolves them: the
+    strategies hand what they are given straight to a CLI, so an unresolved
+    `..` or symlink would survive into the sandbox boundary itself.
+    """
+    root = project_root.resolve()
+    worktree = worktree_path.resolve() if worktree_path is not None else None
+    return WorkerExecRequest(
+        prompt_text=prompt_text,
+        model=model,
+        project_root=root,
+        worktree_path=worktree,
+        # Nobody is at the keyboard to answer an approval prompt, so the gate is
+        # open and the boundary comes from the write scope instead.
+        policy=ExecutionPolicy(
+            auto_approve=True, write_scope=write_scope(root, worktree, role)
+        ),
+        idle_timeout_seconds=idle_timeout_seconds,
+    )
+
+
+def write_scope(
+    project_root: Path, worktree: Path | None, role: str
+) -> tuple[Path, ...]:
+    """What this worker may write, in the order the CLIs are told it.
+
+    The order is contract, not taste: strategies translate this tuple into
+    repeated `--add-dir` positionally, so it mirrors what the shell wrappers
+    claimed. The project root leads (the antigravity wrapper's first
+    `--add-dir`; codex names it with `-C` and its strategy skips the repeat),
+    then the stage tree, then the git directory that tree commits through.
+
+    The worktree belongs here as well as in the request: passing it as the
+    working directory alone produces an argv with no `--add-dir`, and the worker
+    then fails by not writing files rather than by erroring.
+    """
+    scope = [project_root]
+    if worktree is not None:
+        scope.append(worktree)
+        common_git_dir = git_common_dir(worktree)
+        if common_git_dir is not None:
+            scope.append(common_git_dir)
+    scope.extend(verifier_extra_dirs(role))
+    return tuple(scope)
+
+
+def git_common_dir(worktree: Path) -> Path | None:
+    """The main repository's `.git`, which a linked worktree commits through.
+
+    A linked worktree keeps its index and refs under the main repo's `.git` and
+    shares its object database, so a worker bounded to the tree alone cannot
+    `git commit` from it. A directory that is no worktree at all simply has
+    nothing extra to grant.
+    """
+    try:
+        probe = subprocess.run(
+            ["git", "-C", str(worktree), "rev-parse", "--git-common-dir"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except OSError:
+        return None
+    if probe.returncode != 0 or not probe.stdout.strip():
+        return None
+    candidate = Path(probe.stdout.strip())
+    if not candidate.is_absolute():
+        candidate = worktree / candidate
+    return candidate.resolve() if candidate.is_dir() else None
+
+
+def verifier_extra_dirs(role: str) -> tuple[Path, ...]:
+    """Toolchain directories granted to the verifier role only.
+
+    Role decides this, not the provider, so it is assembled here rather than in
+    a strategy — and not in `WorkerRoleSpec`, which holds values that hold for
+    every machine while these paths exist only where the toolchain is.
+    """
+    if role != _VERIFIER_ROLE:
+        return ()
+    home = Path.home()
+    raw = os.environ.get(VERIFIER_EXTRA_DIRS_ENV, f"{home}/.cargo:{home}/.rustup")
+    candidates = (Path(entry) for entry in raw.split(":") if entry)
+    return tuple(path.resolve() for path in candidates if path.is_dir())
+
+
+def idle_timeout(raw: str, role: str) -> int:
+    """The explicit budget, or the one the role's spec owns.
+
+    The default is not written here. The same 1500/600 pair used to live in
+    every wrapper and in the python entrypoint, and each copy could drift from
+    the policy. Raises ``ValueError`` on a malformed budget; the exit code that
+    failure earns belongs to the entrypoint, not to this module.
+    """
+    if not raw:
+        return role_spec(role).idle_timeout_seconds
+    if not raw.isdigit():
+        raise ValueError(
+            f"idle-timeout-seconds must be a non-negative integer: {raw!r}"
+        )
+    return int(raw)