claude-dev-env 8.69.0 → 8.70.0

package/.agents/skills/correction/SKILL.md

@@ -1,16 +1,34 @@
 ---
 name: correction
-description: Turn a correction the user just made into a short handoff brief they paste into a corrections intake, or land the fix in this session with the fix playbook. Use when the user types /correction followed by what the agent got wrong, or /correction fix to land the fix here.
+description: File a correction the user made to an agent as one labeled GitHub issue, list the open corrections, write a handoff brief, or land the fix in this session with the fix playbook. Use when the user types /correction, /correction fix, says "file this as a correction", or asks to show the open corrections.
 argument-hint: "[fix] <what the agent got wrong, in the user's words>"
 ---
 
 # /correction
 
-The user corrected an agent and wants the fix to stick. Write one brief that records the correction. By default the user pastes it into the place that turns corrections into lasting fixes. When `$ARGUMENTS` starts with the word `fix`, this session lands the fix itself.
+The user corrected an agent and wants the fix to stick. A labeled issue is the shared store a corrections project watches. When `$ARGUMENTS` starts with the word `fix`, this session lands the fix itself: write the brief, then follow the fix playbook.
 
-`$ARGUMENTS` is the user's statement of the correction, after a leading `fix` when one is present. Fill the other fields from this session: the transcript, the files and pull requests it touched, and the messages it sent. When the session does not settle a field, write `unknown` there.
+## File it
 
-Print the brief as one fenced `text` block:
+Use this for `/correction <text>` and "file this as a correction: <text>". Run:
+
+```bash
+python "${CLAUDE_SKILL_DIR}/scripts/correction_filing.py" file <<'CORRECTION'
+<the correction, word for word>
+CORRECTION
+```
+
+Pass the user's words exactly. The quoted heredoc keeps the shell from expanding `$`, backticks, and quotes in them. Print the one line the command prints, `Filed: <url>` or `Already filed: <url>`, and nothing else.
+
+When it prints `No correction filing config`, write the brief below instead and tell the user the config file it names.
+
+## List them
+
+For "show the open corrections", run `python "${CLAUDE_SKILL_DIR}/scripts/correction_filing.py" list` and print its lines.
+
+## Brief
+
+Print one fenced `text` block. Fill the fields from this session: the transcript, the files and pull requests it touched, and the messages it sent. Write `unknown` for a field the session does not settle.
 
 ```text
 Correction: <$ARGUMENTS word for word, minus a leading fix>
@@ -28,12 +46,16 @@ Keep each field to one or two lines. Leave out the layer and the fix design; the
 
 | Mode | What follows the brief |
 |---|---|
-| Hand off, the default | Nothing. The brief is the whole reply. |
+| File, the default | The filed line, or the brief when no config exists. |
 | `fix` | Read [`playbooks/fix.md`](playbooks/fix.md) right after the brief, and run its steps from step 2. |
 
 ## Layout
 
 | File | What it holds |
 |---|---|
-| `SKILL.md` | The brief and the playbook index |
+| `SKILL.md` | Filing, the brief, and the playbook index |
 | `playbooks/fix.md` | The steps that land one correction as a control and a pull request in this session |
+| `scripts/correction_filing.py` | Files one correction as a labeled issue, deduplicated, or lists the open ones |
+| `scripts/correction_filing_constants/config/constants.py` | Config keys, issue shape, and redaction patterns |
+| `scripts/test_correction_filing.py` | Behavior tests with a stand-in `gh` |
+| `references/filing.md` | Config file, issue shape, dedupe, and commands |

package/.agents/skills/correction/references/filing.md

@@ -0,0 +1,33 @@
+# Correction filing
+
+`scripts/correction_filing.py` is the one filing path. The skill calls it.
+
+## Config
+
+The script reads `~/.claude/correction-capture.json`, or the file `CLAUDE_CORRECTION_CAPTURE_PATH` names:
+
+```json
+{"repository": "owner/name", "label": "correction"}
+```
+
+Keep this file private. Without it the script files nothing and exits 1.
+
+## Issue shape
+
+- Title: `Correction: ` and the first 72 characters of the text.
+- Body: the source (`typed`, `flag`, `reaction`, or `hook`), the text as a quote, and a hidden dedupe marker.
+- The script masks GitHub, OpenAI, Slack, and AWS tokens and email addresses before filing.
+- The script applies the label itself.
+
+## Dedupe
+
+The key is a hash of `--dedupe-key` when given, else of the whitespace-collapsed text. A caller with a message id passes it there. Before filing, the script checks `correction-capture-filed.json` beside the config file for this repository and key, then every labeled issue, open and closed, and prints `Already filed: <url>` on a key match. The local file covers the minute after filing, when the labeled-issue listing can miss a new issue.
+
+## Commands
+
+Without `--text`, `file` reads the correction from standard input.
+
+```bash
+python correction_filing.py file [--text "<text>"] [--source flag] [--dedupe-key <id>]
+python correction_filing.py list
+```

package/.agents/skills/correction/scripts/correction_filing.py

@@ -0,0 +1,327 @@
+"""File a user's correction as one labeled GitHub issue, or list the open ones.
+
+The repository and label come from a private config file, so nothing
+identifying lives in this package::
+
+    ~/.claude/correction-capture.json
+    {"repository": "owner/name", "label": "correction"}
+
+    python correction_filing.py file --text "use shorter replies"
+    Filed: https://github.com/owner/name/issues/12
+    python correction_filing.py file --text "use shorter replies"
+    Already filed: https://github.com/owner/name/issues/12
+    python correction_filing.py file <<'CORRECTION'
+    use shorter replies
+    CORRECTION
+    Already filed: https://github.com/owner/name/issues/12
+    python correction_filing.py list
+    #12 Correction: use shorter replies https://github.com/...
+
+The issue quotes only the correction text, with tokens and email addresses
+masked. A hidden dedupe marker in the body, and a local ledger of filed keys
+beside the config file, keep a replayed correction from filing twice. CLAUDE_CORRECTION_CAPTURE_PATH names another config file.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import quote
+
+from correction_filing_constants.config.constants import (
+    ALL_REDACTION_PATTERNS,
+    ALL_SOURCES,
+    BODY_FIELD_TEMPLATE,
+    CLAUDE_DIRECTORY_NAME,
+    CONFIG_ENCODING,
+    CONFIG_FILE_NAME,
+    CONFIG_LABEL_KEY,
+    CONFIG_PATH_ENV_VAR,
+    CONFIG_REPOSITORY_KEY,
+    CREATED_URL_JQ_FILTER,
+    DEDUPE_KEY_LENGTH,
+    DEDUPE_MARKER_PATTERN,
+    DEDUPE_MARKER_TEMPLATE,
+    DEFAULT_SOURCE,
+    DUPLICATE_MESSAGE_TEMPLATE,
+    EMPTY_TEXT_MESSAGE,
+    FAILURE_EXIT_CODE,
+    FILED_MESSAGE_TEMPLATE,
+    GH_EXECUTABLE,
+    LABEL_FIELD_TEMPLATE,
+    LINE_SEPARATOR,
+    ISSUE_BODY_TEMPLATE,
+    ISSUES_CREATE_PATH_TEMPLATE,
+    ISSUES_LIST_JQ_FILTER,
+    ISSUES_LIST_PATH_TEMPLATE,
+    LEDGER_FILE_NAME,
+    LEDGER_KEY_TEMPLATE,
+    ISSUE_TITLE_PREFIX,
+    ISSUE_TITLE_TEXT_LENGTH,
+    LIST_LINE_TEMPLATE,
+    MISSING_CONFIG_MESSAGE_TEMPLATE,
+    NO_OPEN_CORRECTIONS_MESSAGE,
+    REDACTION_PLACEHOLDER,
+    SUCCESS_EXIT_CODE,
+    TITLE_FIELD_TEMPLATE,
+    UTF8_ENCODING,
+    WORD_SEPARATOR,
+)
+
+
+@dataclass(frozen=True)
+class FilingTarget:
+    """The repository and label a correction files into."""
+
+    repository: str
+    label: str
+
+
+class FilingConfigMissing(ValueError):
+    """Stop the run when the private config file is absent or incomplete."""
+
+
+def _config_path() -> Path:
+    """Return the config path from the environment, or the default under ~/.claude."""
+    configured_path = os.environ.get(CONFIG_PATH_ENV_VAR, "")
+    if configured_path:
+        return Path(configured_path)
+    return Path.home() / CLAUDE_DIRECTORY_NAME / CONFIG_FILE_NAME
+
+
+def load_filing_target(from_path: Path) -> FilingTarget:
+    """Read the repository and label from the config file.
+
+    Args:
+        from_path: the private config file.
+
+    Returns:
+        The repository and label to file into.
+
+    Raises:
+        FilingConfigMissing: the file is absent, unreadable, or lacks a key.
+    """
+    missing_message = MISSING_CONFIG_MESSAGE_TEMPLATE.format(path=from_path)
+    try:
+        parsed_config = json.loads(from_path.read_text(encoding=CONFIG_ENCODING))
+    except (OSError, ValueError) as error:
+        raise FilingConfigMissing(missing_message) from error
+    if not isinstance(parsed_config, dict):
+        raise FilingConfigMissing(missing_message)
+    repository = parsed_config.get(CONFIG_REPOSITORY_KEY, "")
+    label = parsed_config.get(CONFIG_LABEL_KEY, "")
+    if not isinstance(repository, str) or not isinstance(label, str):
+        raise FilingConfigMissing(missing_message)
+    if not repository or not label:
+        raise FilingConfigMissing(missing_message)
+    return FilingTarget(repository=repository, label=label)
+
+
+def _redact_sensitive_text(correction_text: str) -> str:
+    """Mask tokens, keys, and email addresses in the correction text."""
+    redacted_text = correction_text
+    for each_pattern in ALL_REDACTION_PATTERNS:
+        redacted_text = re.sub(each_pattern, REDACTION_PLACEHOLDER, redacted_text)
+    return redacted_text
+
+
+def _dedupe_key_for(correction_text: str, supplied_key: str) -> str:
+    """Return a hex key that names this correction across replays."""
+    key_source = supplied_key or WORD_SEPARATOR.join(correction_text.split())
+    full_digest = hashlib.sha256(key_source.encode(UTF8_ENCODING)).hexdigest()
+    return full_digest[:DEDUPE_KEY_LENGTH]
+
+
+def issue_title_for(correction_text: str) -> str:
+    """Return a one-line issue title cut from the correction text.
+
+    Args:
+        correction_text: the redacted correction.
+
+    Returns:
+        The prefix and the first characters of the text on one line.
+    """
+    single_line_text = WORD_SEPARATOR.join(correction_text.split())
+    return ISSUE_TITLE_PREFIX + single_line_text[:ISSUE_TITLE_TEXT_LENGTH]
+
+
+def issue_body_for(correction_text: str, source: str, dedupe_key: str) -> str:
+    """Return the issue body with the quoted correction, its source, and the marker.
+
+    Args:
+        correction_text: the redacted correction.
+        source: where the correction came from.
+        dedupe_key: the hex key the marker carries.
+
+    Returns:
+        The markdown issue body.
+    """
+    quoted_text = LINE_SEPARATOR.join(
+        "> " + each_line for each_line in correction_text.splitlines()
+    )
+    return ISSUE_BODY_TEMPLATE.format(
+        source=source,
+        quoted_text=quoted_text,
+        dedupe_marker=DEDUPE_MARKER_TEMPLATE.format(key=dedupe_key),
+    )
+
+
+def _run_gh(all_arguments: list[str]) -> str:
+    completed_process = subprocess.run(
+        [GH_EXECUTABLE, *all_arguments],
+        capture_output=True,
+        text=True,
+        encoding=UTF8_ENCODING,
+        check=True,
+    )
+    return completed_process.stdout
+
+
+def _list_labeled_issues(target: FilingTarget, state: str) -> list[dict[str, object]]:
+    """Return the issues carrying the label, with number, title, url, and body."""
+    issues_path = ISSUES_LIST_PATH_TEMPLATE.format(
+        repository=target.repository, label=quote(target.label), state=state
+    )
+    issue_lines = _run_gh(["api", "--paginate", issues_path, "--jq", ISSUES_LIST_JQ_FILTER])
+    return [json.loads(each_line) for each_line in issue_lines.splitlines() if each_line.strip()]
+
+
+def _ledger_path() -> Path:
+    return _config_path().with_name(LEDGER_FILE_NAME)
+
+
+def _read_ledger() -> dict[str, str]:
+    try:
+        parsed_ledger = json.loads(_ledger_path().read_text(encoding=CONFIG_ENCODING))
+    except (OSError, ValueError):
+        return {}
+    return parsed_ledger if isinstance(parsed_ledger, dict) else {}
+
+
+def _ledger_key_for(target: FilingTarget, dedupe_key: str) -> str:
+    return LEDGER_KEY_TEMPLATE.format(repository=target.repository, dedupe_key=dedupe_key)
+
+
+def _record_in_ledger(target: FilingTarget, dedupe_key: str, issue_url: str) -> None:
+    url_by_ledger_key = _read_ledger()
+    url_by_ledger_key[_ledger_key_for(target, dedupe_key)] = issue_url
+    _ledger_path().write_text(json.dumps(url_by_ledger_key), encoding=CONFIG_ENCODING)
+
+
+def _find_filed_issue_url(target: FilingTarget, dedupe_key: str) -> str:
+    """Return the url of an issue already carrying this dedupe key, or empty."""
+    ledger_url = _read_ledger().get(_ledger_key_for(target, dedupe_key), "")
+    if ledger_url:
+        return ledger_url
+    for each_issue in _list_labeled_issues(target, "all"):
+        each_match = re.search(DEDUPE_MARKER_PATTERN, str(each_issue.get("body", "")))
+        if each_match and each_match.group(1) == dedupe_key:
+            return str(each_issue.get("url", ""))
+    return ""
+
+
+def _file_correction(
+    target: FilingTarget, correction_text: str, source: str, supplied_key: str
+) -> str:
+    """File the correction once and return the message to print."""
+    redacted_text = _redact_sensitive_text(correction_text.strip())
+    dedupe_key = _dedupe_key_for(redacted_text, supplied_key)
+    existing_url = _find_filed_issue_url(target, dedupe_key)
+    if existing_url:
+        return DUPLICATE_MESSAGE_TEMPLATE.format(url=existing_url)
+    created_url = _run_gh(
+        [
+            "api",
+            "--method",
+            "POST",
+            ISSUES_CREATE_PATH_TEMPLATE.format(repository=target.repository),
+            "-f",
+            TITLE_FIELD_TEMPLATE.format(value=issue_title_for(redacted_text)),
+            "-f",
+            BODY_FIELD_TEMPLATE.format(value=issue_body_for(redacted_text, source, dedupe_key)),
+            "-f",
+            LABEL_FIELD_TEMPLATE.format(value=target.label),
+            "--jq",
+            CREATED_URL_JQ_FILTER,
+        ]
+    ).strip()
+    _record_in_ledger(target, dedupe_key, created_url)
+    return FILED_MESSAGE_TEMPLATE.format(url=created_url)
+
+
+def _open_corrections_listing(target: FilingTarget) -> str:
+    """Return one line per open labeled issue, or a no-open line."""
+    all_open_issues = _list_labeled_issues(target, "open")
+    if not all_open_issues:
+        return NO_OPEN_CORRECTIONS_MESSAGE
+    return "".join(
+        LIST_LINE_TEMPLATE.format(
+            number=each_issue["number"],
+            title=each_issue["title"],
+            url=each_issue["url"],
+        )
+        for each_issue in all_open_issues
+    )
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="File or list user corrections.")
+    all_subcommands = parser.add_subparsers(dest="command", required=True)
+    file_parser = all_subcommands.add_parser("file", help="File one correction.")
+    file_parser.add_argument("--text", default=None)
+    file_parser.add_argument("--source", choices=ALL_SOURCES, default=DEFAULT_SOURCE)
+    file_parser.add_argument("--dedupe-key", default="")
+    all_subcommands.add_parser("list", help="List the open corrections.")
+    return parser
+
+
+def _run_command(target: FilingTarget, parsed_arguments: argparse.Namespace) -> int:
+    if parsed_arguments.command == "list":
+        sys.stdout.write(_open_corrections_listing(target))
+        return SUCCESS_EXIT_CODE
+    correction_text = (
+        sys.stdin.buffer.read().decode(UTF8_ENCODING)
+        if parsed_arguments.text is None
+        else parsed_arguments.text
+    )
+    if not correction_text.strip():
+        sys.stderr.write(EMPTY_TEXT_MESSAGE)
+        return FAILURE_EXIT_CODE
+    sys.stdout.write(
+        _file_correction(
+            target, correction_text, parsed_arguments.source, parsed_arguments.dedupe_key
+        )
+    )
+    return SUCCESS_EXIT_CODE
+
+
+def main(all_arguments: list[str]) -> int:
+    """Run the file or list command.
+
+    Args:
+        all_arguments: the command-line arguments after the script name.
+
+    Returns:
+        The process exit code.
+    """
+    parsed_arguments = _build_parser().parse_args(all_arguments)
+    try:
+        target = load_filing_target(_config_path())
+    except FilingConfigMissing as error:
+        sys.stderr.write(str(error))
+        return FAILURE_EXIT_CODE
+    try:
+        return _run_command(target, parsed_arguments)
+    except subprocess.CalledProcessError as error:
+        sys.stderr.write(error.stderr or str(error))
+        return FAILURE_EXIT_CODE
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/.agents/skills/correction/scripts/correction_filing_constants/config/constants.py

@@ -0,0 +1,56 @@
+"""Configuration constants for the correction filing command."""
+
+ALL_REDACTION_PATTERNS = (
+    r"gh[pousr]_[A-Za-z0-9]{20,}",
+    r"github_pat_[A-Za-z0-9_]{20,}",
+    r"sk-[A-Za-z0-9_-]{20,}",
+    r"xox[abprs]-[A-Za-z0-9-]{10,}",
+    r"AKIA[0-9A-Z]{16}",
+    r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}",
+)
+BODY_FIELD_TEMPLATE = "body={value}"
+ALL_SOURCES = ("typed", "flag", "reaction", "hook")
+CLAUDE_DIRECTORY_NAME = ".claude"
+CONFIG_ENCODING = "utf-8"
+CONFIG_FILE_NAME = "correction-capture.json"
+CONFIG_LABEL_KEY = "label"
+CONFIG_PATH_ENV_VAR = "CLAUDE_CORRECTION_CAPTURE_PATH"
+CONFIG_REPOSITORY_KEY = "repository"
+CREATED_URL_JQ_FILTER = ".html_url"
+DEDUPE_MARKER_PATTERN = r"<!-- correction-dedupe: ([0-9a-f]{16,64}) -->"
+DEDUPE_MARKER_TEMPLATE = "<!-- correction-dedupe: {key} -->"
+DEDUPE_KEY_LENGTH = 16
+DEFAULT_SOURCE = "typed"
+DUPLICATE_MESSAGE_TEMPLATE = "Already filed: {url}\n"
+EMPTY_TEXT_MESSAGE = "The correction text is empty. Nothing was filed.\n"
+FAILURE_EXIT_CODE = 1
+FILED_MESSAGE_TEMPLATE = "Filed: {url}\n"
+GH_EXECUTABLE = "gh"
+ISSUE_BODY_TEMPLATE = (
+    "A correction the user made to an agent.\n\n"
+    "Source: {source}\n\n"
+    "{quoted_text}\n\n"
+    "{dedupe_marker}\n"
+)
+ISSUES_CREATE_PATH_TEMPLATE = "repos/{repository}/issues"
+ISSUES_LIST_JQ_FILTER = (
+    ".[] | select(.pull_request | not) | {number, title, url: .html_url, body}"
+)
+ISSUES_LIST_PATH_TEMPLATE = "repos/{repository}/issues?labels={label}&state={state}&per_page=100"
+ISSUE_TITLE_PREFIX = "Correction: "
+ISSUE_TITLE_TEXT_LENGTH = 72
+LABEL_FIELD_TEMPLATE = "labels[]={value}"
+LEDGER_FILE_NAME = "correction-capture-filed.json"
+LEDGER_KEY_TEMPLATE = "{repository} {dedupe_key}"
+LINE_SEPARATOR = "\n"
+LIST_LINE_TEMPLATE = "#{number} {title} {url}\n"
+MISSING_CONFIG_MESSAGE_TEMPLATE = (
+    "No correction filing config at {path}. Write it as "
+    '{{"repository": "<owner>/<name>", "label": "<label>"}}. Nothing was filed.\n'
+)
+NO_OPEN_CORRECTIONS_MESSAGE = "No open corrections.\n"
+REDACTION_PLACEHOLDER = "[redacted]"
+SUCCESS_EXIT_CODE = 0
+TITLE_FIELD_TEMPLATE = "title={value}"
+UTF8_ENCODING = "utf-8"
+WORD_SEPARATOR = " "

package/.agents/skills/correction/scripts/pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_* should_*

package/.agents/skills/correction/scripts/test_correction_filing.py

@@ -0,0 +1,155 @@
+"""Behavior tests for correction_filing with a stand-in gh on PATH."""
+
+from __future__ import annotations
+
+import importlib
+import io
+import json
+import os
+import stat
+import sys
+from pathlib import Path
+
+import pytest
+
+SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+if str(SCRIPTS_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(SCRIPTS_DIRECTORY))
+
+correction_filing = importlib.import_module("correction_filing")
+
+STAND_IN_GH = r'''#!/usr/bin/env python3
+import json, os, sys
+from urllib.parse import parse_qs, urlsplit
+store = os.environ["STAND_IN_GH_STORE"]
+issues = json.load(open(store)) if os.path.exists(store) else []
+args = sys.argv[1:]
+if "POST" in args:
+    fields = dict(args[i + 1].split("=", 1) for i, a in enumerate(args) if a == "-f")
+    number = len(issues) + 1
+    url = "https://example.test/issues/%d" % number
+    issues.append({"number": number, "title": fields["title"], "url": url,
+                   "body": fields["body"], "label": fields["labels[]"], "state": "open"})
+    json.dump(issues, open(store, "w"))
+    print(url)
+else:
+    query = parse_qs(urlsplit(args[2]).query)
+    state = query["state"][0]
+    for i in issues:
+        if i["label"] == query["labels"][0] and (state == "all" or i["state"] == state):
+            print(json.dumps({k: i[k] for k in ("number", "title", "url", "body")}))
+'''
+
+
+@pytest.fixture
+def filing_environment(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    bin_directory = tmp_path / "bin"
+    bin_directory.mkdir()
+    gh_path = bin_directory / "gh"
+    gh_path.write_text(STAND_IN_GH, encoding="utf-8")
+    gh_path.chmod(gh_path.stat().st_mode | stat.S_IEXEC)
+    store_path = tmp_path / "issues.json"
+    config_file = tmp_path / "correction-capture.json"
+    config_file.write_text(json.dumps({"repository": "owner/name", "label": "correction"}))
+    monkeypatch.setenv("PATH", str(bin_directory) + os.pathsep + os.environ["PATH"])
+    monkeypatch.setenv("STAND_IN_GH_STORE", str(store_path))
+    monkeypatch.setenv("CLAUDE_CORRECTION_CAPTURE_PATH", str(config_file))
+    return store_path
+
+
+def _stored_issues(store_path: Path) -> list[dict[str, object]]:
+    return json.loads(store_path.read_text()) if store_path.exists() else []
+
+
+def test_should_file_one_labeled_issue_quoting_the_text(filing_environment: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    assert correction_filing.main(["file", "--text", "use shorter replies"]) == 0
+    all_issues = _stored_issues(filing_environment)
+    assert len(all_issues) == 1
+    assert all_issues[0]["label"] == "correction"
+    assert "> use shorter replies" in all_issues[0]["body"]
+    assert "Filed: https://example.test/issues/1" in capsys.readouterr().out
+
+
+def test_should_file_a_replayed_correction_once(filing_environment: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    correction_filing.main(["file", "--text", "stop  asking me"])
+    assert correction_filing.main(["file", "--text", "stop asking me"]) == 0
+    assert len(_stored_issues(filing_environment)) == 1
+    assert "Already filed: https://example.test/issues/1" in capsys.readouterr().out
+
+
+def test_should_dedupe_on_a_supplied_key(filing_environment: Path) -> None:
+    correction_filing.main(["file", "--text", "first", "--dedupe-key", "msg-7"])
+    correction_filing.main(["file", "--text", "second", "--dedupe-key", "msg-7"])
+    correction_filing.main(["file", "--text", "second", "--dedupe-key", "msg-8"])
+    assert len(_stored_issues(filing_environment)) == 2
+
+
+def test_should_mask_tokens_and_emails(filing_environment: Path) -> None:
+    correction_filing.main(
+        ["file", "--text", "you leaked ghp_" + "a" * 36 + " and me@example.com"]
+    )
+    body = _stored_issues(filing_environment)[0]["body"]
+    assert "ghp_" not in body and "me@example.com" not in body
+    assert body.count("[redacted]") == 2
+
+
+def test_should_file_nothing_without_config(filing_environment: Path, monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    monkeypatch.setenv("CLAUDE_CORRECTION_CAPTURE_PATH", str(tmp_path / "absent.json"))
+    assert correction_filing.main(["file", "--text", "anything"]) == 1
+    assert _stored_issues(filing_environment) == []
+    assert "No correction filing config" in capsys.readouterr().err
+
+
+def test_should_file_nothing_for_empty_text(filing_environment: Path) -> None:
+    assert correction_filing.main(["file", "--text", "   "]) == 1
+    assert _stored_issues(filing_environment) == []
+
+
+def test_should_list_open_corrections(filing_environment: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    correction_filing.main(["list"])
+    assert "No open corrections." in capsys.readouterr().out
+    correction_filing.main(["file", "--text", "use plain words"])
+    capsys.readouterr()
+    correction_filing.main(["list"])
+    assert "#1 Correction: use plain words https://example.test/issues/1" in capsys.readouterr().out
+
+
+def test_should_build_title_and_body_from_text() -> None:
+    assert correction_filing.issue_title_for("a\nb") == "Correction: a b"
+    body = correction_filing.issue_body_for("x\ny", "flag", "abcdef0123456789")
+    assert "> x\n> y" in body and "Source: flag" in body
+    assert "<!-- correction-dedupe: abcdef0123456789 -->" in body
+
+
+def test_should_read_target_and_reject_incomplete_config(tmp_path: Path) -> None:
+    good = tmp_path / "good.json"
+    good.write_text(json.dumps({"repository": "o/n", "label": "l"}))
+    assert correction_filing.load_filing_target(good) == correction_filing.FilingTarget("o/n", "l")
+    bad = tmp_path / "bad.json"
+    bad.write_text(json.dumps({"repository": "o/n"}))
+    with pytest.raises(correction_filing.FilingConfigMissing):
+        correction_filing.load_filing_target(bad)
+
+
+def test_should_dedupe_from_the_ledger_when_the_listing_lags(filing_environment: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    correction_filing.main(["file", "--text", "keep replies short"])
+    filing_environment.write_text("[]")
+    capsys.readouterr()
+    correction_filing.main(["file", "--text", "keep replies short"])
+    assert "Already filed: https://example.test/issues/1" in capsys.readouterr().out
+
+
+def test_should_read_the_text_from_stdin_without_expanding_it(filing_environment: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    piped_bytes = 'say "$(whoami)" and `id` in caf\u00e9\n'.encode("utf-8")
+    monkeypatch.setattr(sys, "stdin", io.TextIOWrapper(io.BytesIO(piped_bytes), encoding="cp1252"))
+    assert correction_filing.main(["file"]) == 0
+    assert '> say "$(whoami)" and `id` in caf\u00e9' in _stored_issues(filing_environment)[0]["body"]
+
+
+def test_should_file_again_after_the_config_names_another_repository(filing_environment: Path, tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    correction_filing.main(["file", "--text", "keep replies short"])
+    filing_environment.write_text("[]")
+    (tmp_path / "correction-capture.json").write_text(json.dumps({"repository": "owner/other", "label": "correction"}))
+    capsys.readouterr()
+    correction_filing.main(["file", "--text", "keep replies short"])
+    assert "Filed: https://example.test/issues/1" in capsys.readouterr().out

package/.agents/skills/pr-lifecycle/SKILL.md

@@ -25,7 +25,9 @@ User-level rule: applies to **every** git repo that uses GitHub with `gh`. Small
 **Prove the change where it runs before you open the pull request.** The body carries a
 "Proof in practice" section with each command you ran and its quoted output. A hook denies
 a new pull request without one. Read `~/.claude/docs/rule-guides/proof-before-pull-request.md`
-before you plan the proof run.
+before you plan the proof run. A `feat` pull request also needs an "Eval" section and a
+session that invoked `/claude-api build-eval`; read
+`~/.claude/docs/rule-guides/features-start-with-an-eval.md` before you build the feature.
 
 **Open every pull request ready for review.** Pass `--draft` only when the owner asks
 for a draft.