claude-dev-env 8.89.0 → 8.90.0

package/hooks/session/deepen_role_gate.py

@@ -1,171 +0,0 @@
-"""Refusal checks for a first-task rewrite.
-
-The rewriter lives in ``deepen_first_prompt.py``. This module only scores a
-candidate. A grader imports ``refusal_reason`` and does not rewrite.
-"""
-
-from __future__ import annotations
-
-import re
-
-from hooks_constants.deepen_first_prompt_constants import (
-    ALL_EXAMPLE_NOUN_STOPWORDS,
-    ALL_FOUR_QUESTION_STEMS,
-    EXAMPLE_NOUN_PATTERN,
-    BULLET_PREFIX,
-    HARD_CONSTRAINTS_LABEL,
-    REFUSAL_DROPPED_HARD_CONSTRAINT,
-    REFUSAL_EXAMPLE_NOUN_IN_SCOPE,
-    REFUSAL_MISSING_ROLE_LINES,
-    REFUSAL_RESTATES_FOUR_QUESTIONS,
-    ROLE_BLOCKER_LABEL,
-    ROLE_BLOCKER_NONE,
-    ROLE_EXAMPLES_LABEL,
-    ROLE_SCOPE_LABEL,
-)
-
-
-def _labeled_text(rewritten_prompt: str, label: str) -> str | None:
-    """Return the text after ``label`` on its line, or None when the line is absent."""
-    prefix = label
-    for each_line in rewritten_prompt.splitlines():
-        stripped_line = each_line.strip()
-        if stripped_line.startswith(prefix):
-            return stripped_line[len(prefix) :].strip()
-    return None
-
-
-def _restates_four_questions(rewritten_prompt: str) -> bool:
-    """Return True when the rewrite pastes every canonical question stem."""
-    return all(each_stem in rewritten_prompt for each_stem in ALL_FOUR_QUESTION_STEMS)
-
-
-def _role_lines_are_missing(rewritten_prompt: str) -> bool:
-    """Return True when any of the three role lines is absent or blank."""
-    for each_label in (ROLE_SCOPE_LABEL, ROLE_EXAMPLES_LABEL, ROLE_BLOCKER_LABEL):
-        labeled_text = _labeled_text(rewritten_prompt, each_label)
-        if labeled_text is None or not labeled_text:
-            return True
-    return False
-
-
-def _example_nouns(examples_text: str) -> frozenset[str]:
-    """Return content words from the examples line. ``none`` yields an empty set."""
-    if examples_text.strip().rstrip(".").lower() == ROLE_BLOCKER_NONE:
-        return frozenset()
-    noun_pattern = re.compile(EXAMPLE_NOUN_PATTERN)
-    return frozenset(
-        each_match.group(0).lower()
-        for each_match in noun_pattern.finditer(examples_text)
-        if each_match.group(0).lower() not in ALL_EXAMPLE_NOUN_STOPWORDS
-    )
-
-
-def _scope_names_example_noun(scope_text: str, examples_text: str, blocker_text: str) -> bool:
-    """Return True when the scope line names an example noun and the blocker is none."""
-    if blocker_text.strip().rstrip(".").lower() != ROLE_BLOCKER_NONE:
-        return False
-    for each_noun in _example_nouns(examples_text):
-        if re.search(
-            rf"(?i)(?<![A-Za-z0-9]){re.escape(each_noun)}(?![A-Za-z0-9])",
-            scope_text,
-        ):
-            return True
-    return False
-
-
-def _is_constraints_heading(stripped_line: str) -> bool:
-    """Return whether the line opens the hard-constraints block."""
-    return stripped_line.upper().startswith(HARD_CONSTRAINTS_LABEL)
-
-
-def _bullet_body(stripped_line: str) -> str | None:
-    """Return the text after a bullet marker, or None when the line is not a bullet."""
-    if not stripped_line.startswith(BULLET_PREFIX):
-        return None
-    return stripped_line[len(BULLET_PREFIX) :].strip()
-
-
-def _constraint_step(
-    stripped_line: str,
-    collecting: bool,
-    has_sentences: bool,
-) -> tuple[str | None, bool, bool]:
-    """Return the sentence to keep, whether collection stays on, and whether to stop."""
-    if not collecting:
-        return None, _is_constraints_heading(stripped_line), False
-    bullet_body = _bullet_body(stripped_line)
-    if bullet_body is not None:
-        return bullet_body, True, False
-    if stripped_line == "" and not has_sentences:
-        return None, True, False
-    return None, collecting, True
-
-
-def _constraint_sentences(original_task: str) -> tuple[str, ...]:
-    """Return bullet sentences under the hard-constraints heading."""
-    collecting = False
-    all_sentences: list[str] = []
-    for each_line in original_task.splitlines():
-        sentence, collecting, finished = _constraint_step(
-            each_line.strip(),
-            collecting,
-            bool(all_sentences),
-        )
-        if finished:
-            break
-        if sentence is not None:
-            all_sentences.append(sentence)
-    return tuple(all_sentences)
-
-
-def _line_body(stripped_line: str) -> str | None:
-    """Return one rewrite line with a leading bullet marker removed."""
-    if not stripped_line:
-        return None
-    bullet_body = _bullet_body(stripped_line)
-    if bullet_body is not None:
-        return bullet_body
-    return stripped_line
-
-
-def _rewrite_line_bodies(rewritten_prompt: str) -> frozenset[str]:
-    """Return each rewrite line with a leading bullet marker removed."""
-    all_bodies: set[str] = set()
-    for each_line in rewritten_prompt.splitlines():
-        body = _line_body(each_line.strip())
-        if body is not None:
-            all_bodies.add(body)
-    return frozenset(all_bodies)
-
-
-def _dropped_hard_constraint(original_task: str, rewritten_prompt: str) -> bool:
-    """Return True when a hard-constraint sentence is absent as its own line."""
-    rewrite_bodies = _rewrite_line_bodies(rewritten_prompt)
-    return any(
-        each_sentence not in rewrite_bodies for each_sentence in _constraint_sentences(original_task)
-    )
-
-
-def refusal_reason(original_task: str, rewritten_prompt: str) -> str | None:
-    """Return the refusal reason for one candidate rewrite, or None when it can ship.
-
-    Args:
-        original_task: The task text the rewrite must keep constraints from.
-        rewritten_prompt: The candidate worker prompt.
-
-    Returns:
-        A refusal reason string, or None when the candidate passes.
-    """
-    if _restates_four_questions(rewritten_prompt):
-        return REFUSAL_RESTATES_FOUR_QUESTIONS
-    if _role_lines_are_missing(rewritten_prompt):
-        return REFUSAL_MISSING_ROLE_LINES
-    scope_text = _labeled_text(rewritten_prompt, ROLE_SCOPE_LABEL) or ""
-    examples_text = _labeled_text(rewritten_prompt, ROLE_EXAMPLES_LABEL) or ""
-    blocker_text = _labeled_text(rewritten_prompt, ROLE_BLOCKER_LABEL) or ""
-    if _scope_names_example_noun(scope_text, examples_text, blocker_text):
-        return REFUSAL_EXAMPLE_NOUN_IN_SCOPE
-    if _dropped_hard_constraint(original_task, rewritten_prompt):
-        return REFUSAL_DROPPED_HARD_CONSTRAINT
-    return None

package/hooks/session/deepen_turn_marker.py

@@ -1,75 +0,0 @@
-"""Turn-one marker for the first-task deepen hook.
-
-The marker records that a session already deepened its first task, so later
-prompts stay untouched. A host can run two copies of the hook for one prompt:
-Cursor runs its own ``beforeSubmitPrompt`` entry and the ``UserPromptSubmit``
-entry it imports from the Claude Code settings, side by side. Each copy claims
-the marker by creating the file only when it does not exist yet, so exactly
-one copy wins and injects.
-"""
-
-from __future__ import annotations
-
-import os
-import tempfile
-from pathlib import Path
-
-from hooks_constants.deepen_first_prompt_constants import (
-    DEEPEN_MARKER,
-    DEEPEN_SESSION_MARKER_PREFIX,
-    DEEPEN_TURN_MARKER_SUFFIX,
-    SESSION_ID_FIELD_NAME,
-    TRANSCRIPT_PATH_FIELD_NAME,
-    UTF8_ENCODING,
-)
-
-
-def _all_turn_marker_paths(all_hook_fields: dict[str, object]) -> list[Path]:
-    all_marker_paths: list[Path] = []
-    transcript_path = all_hook_fields.get(TRANSCRIPT_PATH_FIELD_NAME)
-    if isinstance(transcript_path, str) and transcript_path:
-        all_marker_paths.append(Path(transcript_path + DEEPEN_TURN_MARKER_SUFFIX))
-    session_id = all_hook_fields.get(SESSION_ID_FIELD_NAME)
-    if isinstance(session_id, str) and session_id:
-        all_marker_paths.append(Path(tempfile.gettempdir()) / f"{DEEPEN_SESSION_MARKER_PREFIX}{session_id}")
-    return all_marker_paths
-
-
-def turn_marker_path(all_hook_fields: dict[str, object]) -> Path | None:
-    """Return the marker path for this session, or None when the payload names none.
-
-    The transcript path wins when the payload has one. Cursor sends no transcript
-    path before the first reply, so the session id names a file in the system
-    temp folder instead.
-    """
-    all_marker_paths = _all_turn_marker_paths(all_hook_fields)
-    return all_marker_paths[0] if all_marker_paths else None
-
-
-def turn_marker_exists(all_hook_fields: dict[str, object]) -> bool:
-    """Return True when this session already deepened a task.
-
-    Both marker locations count. Cursor's first prompt claims the session marker
-    because it has no transcript path yet, and a later prompt carries one.
-    """
-    return any(each_marker_path.is_file() for each_marker_path in _all_turn_marker_paths(all_hook_fields))
-
-
-def claim_turn_marker(all_hook_fields: dict[str, object]) -> bool:
-    """Create the marker, and return False when another copy created it first.
-
-    A payload with no transcript path or session id, or a marker that cannot be
-    written, returns True: the hook then deepens without a guard, as before.
-    """
-    marker_path = turn_marker_path(all_hook_fields)
-    if marker_path is None:
-        return True
-    try:
-        marker_descriptor = os.open(marker_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
-    except FileExistsError:
-        return False
-    except OSError:
-        return True
-    with os.fdopen(marker_descriptor, "w", encoding=UTF8_ENCODING) as marker_file:
-        marker_file.write(DEEPEN_MARKER)
-    return True

package/hooks/session/fixtures/deepstack_replay.json

@@ -1,15 +0,0 @@
-{
-  "task": "Keep the build green. For example, the login failure.\n\nHARD CONSTRAINTS\n- Never open a pull request.\n",
-  "cases": [
-    {
-      "name": "known_bad",
-      "expect": "refuse",
-      "rewrittenPrompt": "CDE_DEEPEN:v1\nSCOPE (role): Fix the login failure\nEXAMPLES (illustration only): login failure\nZOOM-IN BLOCKER: none\n- Never open a pull request.\nRead the workflow log and repair the shared gate.\n"
-    },
-    {
-      "name": "known_good",
-      "expect": "accept",
-      "rewrittenPrompt": "CDE_DEEPEN:v1\nSCOPE (role): Keep every build green across the repository\nEXAMPLES (illustration only): login failure\nZOOM-IN BLOCKER: none\n- Never open a pull request.\nRead the workflow log and repair the shared gate.\n"
-    }
-  ]
-}

package/hooks/session/grade_deepstack_replay.py

@@ -1,78 +0,0 @@
-#!/usr/bin/env python3
-"""Score a replay fixture. This script does not rewrite the task."""
-
-from __future__ import annotations
-
-import json
-import sys
-from pathlib import Path
-
-_SESSION_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _SESSION_DIR.parent
-for each_sys_path_entry in (str(_SESSION_DIR), str(_HOOKS_ROOT)):
-    if each_sys_path_entry not in sys.path:
-        sys.path.insert(0, each_sys_path_entry)
-
-from deepen_role_gate import refusal_reason
-from hooks_constants.deepen_first_prompt_constants import (
-    SCORE_ACCEPT,
-    SCORE_REFUSE,
-    UTF8_ENCODING,
-)
-
-
-def score_replay(task_text: str, rewritten_prompt: str) -> dict[str, str]:
-    """Return accept, or refuse plus the gate reason. Never rewrite the task."""
-    reason = refusal_reason(task_text, rewritten_prompt)
-    if reason is None:
-        return {"score": SCORE_ACCEPT}
-    return {"score": SCORE_REFUSE, "reason": reason}
-
-
-def score_fixture(all_replay_fields: dict[str, object]) -> list[dict[str, str]]:
-    """Score each case in a replay fixture against the task it names."""
-    task_text = all_replay_fields["task"]
-    if not isinstance(task_text, str):
-        raise TypeError("fixture task must be a string")
-    cases = all_replay_fields["cases"]
-    if not isinstance(cases, list):
-        raise TypeError("fixture cases must be a list")
-    all_scores: list[dict[str, str]] = []
-    for each_case in cases:
-        if not isinstance(each_case, dict):
-            raise TypeError("each fixture case must be an object")
-        case_name = each_case["name"]
-        rewritten_prompt = each_case["rewrittenPrompt"]
-        expected_score = each_case["expect"]
-        if not isinstance(case_name, str) or not isinstance(rewritten_prompt, str):
-            raise TypeError("case name and rewrittenPrompt must be strings")
-        if not isinstance(expected_score, str):
-            raise TypeError("case expect must be a string")
-        scored = score_replay(task_text, rewritten_prompt)
-        scored["name"] = case_name
-        scored["expect"] = expected_score
-        scored["matched"] = "yes" if scored["score"] == expected_score else "no"
-        all_scores.append(scored)
-    return all_scores
-
-
-def main(all_arguments: list[str]) -> int:
-    """Read one fixture path and print a score line per case."""
-    if len(all_arguments) != 1:
-        sys.stderr.write("usage: grade_deepstack_replay.py <fixture.json>\n")
-        return 2
-    fixture_path = Path(all_arguments[0])
-    fixture = json.loads(fixture_path.read_text(encoding=UTF8_ENCODING))
-    if not isinstance(fixture, dict):
-        sys.stderr.write("fixture root must be an object\n")
-        return 2
-    all_scores = score_fixture(fixture)
-    for each_score in all_scores:
-        sys.stdout.write(json.dumps(each_score) + "\n")
-    if any(each_score["matched"] != "yes" for each_score in all_scores):
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))

package/hooks/session/test_deepen_default_rewrite.py

@@ -1,90 +0,0 @@
-"""Tests for the role-shaped default rewrite."""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-
-from deepen_default_rewrite import role_default_rewrite
-from deepen_role_gate import refusal_reason
-from hooks_constants.deepen_first_prompt_constants import ALL_FOUR_QUESTION_STEMS, DEEPEN_MARKER
-
-
-def _role_line(rewrite: str, label: str) -> str:
-    return next(each for each in rewrite.splitlines() if each.startswith(label))[len(label) :].strip()
-
-
-def test_should_pass_the_gate_for_a_plain_task() -> None:
-    task = "Add dark mode to the settings page"
-    rewrite = role_default_rewrite(task)
-    assert rewrite.startswith(DEEPEN_MARKER)
-    assert refusal_reason(task, rewrite) is None
-    assert _role_line(rewrite, "SCOPE (role):") == task
-    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "none"
-
-
-def test_should_not_paste_the_four_question_stems() -> None:
-    rewrite = role_default_rewrite("Add dark mode to the settings page")
-    assert not any(each_stem in rewrite for each_stem in ALL_FOUR_QUESTION_STEMS)
-
-
-def test_should_move_a_marked_example_out_of_the_scope() -> None:
-    task = "fix the flaky tests, e.g. test_auth and test_cache, and keep CI fast"
-    rewrite = role_default_rewrite(task)
-    assert refusal_reason(task, rewrite) is None
-    assert _role_line(rewrite, "SCOPE (role):") == "fix the flaky tests and keep CI fast"
-    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "test_auth and test_cache"
-
-
-def test_should_ask_before_narrowing_when_the_scope_names_the_example() -> None:
-    task = "Fix the login failure. For example, the login failure on Safari."
-    rewrite = role_default_rewrite(task)
-    assert refusal_reason(task, rewrite) is None
-    assert _role_line(rewrite, "ZOOM-IN BLOCKER:").startswith("the scope names something")
-
-
-def test_should_keep_every_hard_constraint_line() -> None:
-    task = "Keep the build green. For example, the login failure.\n\nHARD CONSTRAINTS\n- Never open a pull request.\n"
-    rewrite = role_default_rewrite(task)
-    assert refusal_reason(task, rewrite) is None
-    assert "- Never open a pull request." in rewrite.splitlines()
-
-
-def test_should_keep_every_task_sentence_in_scope_when_the_task_opens_with_context() -> None:
-    task = "We have a Django app. Add CSV export to the reports page, e.g. the monthly sales report, and keep the existing URLs."
-    rewrite = role_default_rewrite(task)
-    assert refusal_reason(task, rewrite) is None
-    assert _role_line(rewrite, "SCOPE (role):") == (
-        "We have a Django app. Add CSV export to the reports page and keep the existing URLs."
-    )
-    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "the monthly sales report"
-
-
-def test_should_clip_a_long_scope_and_point_at_the_full_task() -> None:
-    task = "Refactor the module. " * 40
-    rewrite = role_default_rewrite(task.strip())
-    scope = _role_line(rewrite, "SCOPE (role):")
-    assert scope.endswith("(the rest is in the task below)")
-    assert len(scope) < len(task)
-    assert refusal_reason(task.strip(), rewrite) is None
-
-
-def test_should_keep_a_marker_word_inside_a_longer_word_in_the_scope() -> None:
-    task = "Search the codebase for examples of deprecated API calls and replace each one with the new client."
-    rewrite = role_default_rewrite(task)
-    assert refusal_reason(task, rewrite) is None
-    assert _role_line(rewrite, "SCOPE (role):") == task
-    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "none"
-    assumption_task = "Avoid such assumptions in the parser and add input validation."
-    assert _role_line(role_default_rewrite(assumption_task), "SCOPE (role):") == assumption_task
-
-
-def test_should_move_every_marked_example_in_a_sentence_out_of_the_scope() -> None:
-    task = "Speed up the slow pages such as the dashboard, and cache reads, e.g. the user lookup, and keep the API stable."
-    rewrite = role_default_rewrite(task)
-    assert refusal_reason(task, rewrite) is None
-    assert _role_line(rewrite, "SCOPE (role):") == "Speed up the slow pages and cache reads and keep the API stable."
-    assert _role_line(rewrite, "EXAMPLES (illustration only):") == "the dashboard; the user lookup"