@rpamis/comet 0.4.0-beta.6 → 0.4.0-beta.7

package/eval/local/tasks/comet-native-repository-fact/environment/test_wordcount.py

@@ -0,0 +1,20 @@
+import subprocess
+import sys
+
+
+def run_cli(*args: str, input_text: str) -> str:
+    return subprocess.run(
+        [sys.executable, "wordcount.py", *args],
+        input=input_text,
+        capture_output=True,
+        text=True,
+        check=True,
+    ).stdout
+
+
+def test_count_words():
+    assert "Words: 3" in run_cli(input_text="hello world foo")
+
+
+def test_count_lines():
+    assert "Lines: 3" in run_cli("--lines", input_text="hello\nworld\nfoo")

package/eval/local/tasks/comet-native-repository-fact/environment/wordcount.py

@@ -0,0 +1,27 @@
+"""Simple word count CLI tool."""
+
+import argparse
+import sys
+
+
+def count_words(text: str) -> int:
+    return len(text.split())
+
+
+def count_lines(text: str) -> int:
+    return len(text.splitlines())
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Count words and lines in text")
+    parser.add_argument("file", nargs="?", help="Input file (reads stdin if omitted)")
+    parser.add_argument("--lines", action="store_true", help="Also count lines")
+    args = parser.parse_args()
+    text = open(args.file).read() if args.file else sys.stdin.read()
+    print(f"Words: {count_words(text)}")
+    if args.lines:
+        print(f"Lines: {count_lines(text)}")
+
+
+if __name__ == "__main__":
+    main()

package/eval/local/tasks/comet-native-repository-fact/instruction.md

@@ -0,0 +1,7 @@
+You are working on a Python project named `wordcount-cli`.
+
+Begin by invoking the `/comet-native` Skill. Initialize Native under `docs/comet/`, create a change, and add a `--paragraphs` flag that prints `Paragraphs: N` while preserving existing word and line counts.
+
+The exact paragraph-boundary rule is already documented somewhere in this repository. Investigate the repository and use that fact; do not ask the user to repeat repository facts or choose an implementation method. Write a detailed brief and a complete `paragraph-counting` target specification, implement focused tests, verify, and archive with implicit Shape approval.
+
+Use only the Comet Native Skill and bundled runtime. Do not create OpenSpec, Classic, `.comet`, or external workflow artifacts.

package/eval/local/tasks/comet-native-repository-fact/task.toml

@@ -0,0 +1,35 @@
+[metadata]
+name = "comet-native-repository-fact"
+description = "Test that Native investigates a repository fact instead of asking the user"
+difficulty = "hard"
+category = "comet-native"
+tags = ["comet-native", "repository-fact", "autonomy", "full-cycle"]
+default_treatments = ["COMET_NATIVE_PHASE1"]
+
+[template]
+required = []
+
+[environment]
+description = "Python word-count workspace whose paragraph rule is documented in the repository."
+dockerfile = "environment/Dockerfile"
+timeout_sec = 900
+
+[validation]
+test_scripts = "test_native_repository_fact.py"
+target_artifacts = ["docs/comet/archive", "docs/comet/specs/paragraph-counting/spec.md"]
+timeout = 120
+
+[evaluation]
+profile = "generic"
+required_skills = ["comet-native"]
+expected_artifacts = [".comet/config.yaml", "docs/comet/archive", "docs/comet/specs/paragraph-counting/spec.md"]
+require_skill_invocation = true
+rubric_criteria = [
+  "Reads PRODUCT_RULES.md and does not ask the user to restate repository facts",
+  "Records the documented whitespace-only paragraph boundary without explicit user confirmation",
+  "Completes the self-contained Native workflow and archives real verification evidence",
+]
+
+[interaction]
+mode = "none"
+max_turns = 1

package/eval/local/tasks/comet-native-repository-fact/validation/test_native_repository_fact.py

@@ -0,0 +1,53 @@
+"""Validate repository-fact discovery and implicit Native completion."""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import yaml
+
+
+WORKSPACE = Path("/workspace")
+RESULTS_FILE = os.environ.get("BENCH_TEST_RESULTS", "_test_results.json")
+
+
+def check_behavior():
+    subprocess.run([sys.executable, "-m", "pytest", "-q"], cwd=WORKSPACE, check=True)
+    result = subprocess.run(
+        [sys.executable, "wordcount.py", "--paragraphs"],
+        cwd=WORKSPACE,
+        input="First block\ncontinues\n\n   \nSecond block",
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert "Paragraphs: 2" in result.stdout
+
+
+def check_native():
+    archives = sorted((WORKSPACE / "docs/comet/archive").glob("*-*"))
+    assert archives
+    state = yaml.safe_load((archives[-1] / "comet-state.yaml").read_text(encoding="utf-8"))
+    assert state["approval"] == "implicit"
+    brief = (archives[-1] / "brief.md").read_text(encoding="utf-8").lower()
+    assert "whitespace" in brief or "blank line" in brief
+    assert (WORKSPACE / "docs/comet/specs/paragraph-counting/spec.md").is_file()
+
+
+def main():
+    failed = []
+    for name, check in (("paragraph_behavior", check_behavior), ("native_artifacts", check_native)):
+        try:
+            check()
+        except Exception as error:
+            failed.append(f"{name}: {error}")
+    output = {"passed": [] if failed else ["paragraph_behavior", "native_artifacts"], "failed": failed}
+    (WORKSPACE / RESULTS_FILE).write_text(json.dumps(output, indent=2), encoding="utf-8")
+    print(json.dumps(output))
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/eval/local/tasks/comet-native-wave-b-decision-resume/environment/Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.12-slim
+
+WORKDIR /workspace
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git nodejs npm ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN npm config set registry https://registry.npmmirror.com && \
+    npm install -g @anthropic-ai/claude-code@latest && \
+    npm config delete registry
+
+RUN pip install --no-cache-dir pyyaml pytest
+
+COPY wordcount.py /workspace/wordcount.py
+COPY test_wordcount.py /workspace/test_wordcount.py
+
+RUN useradd --create-home --shell /bin/bash agent && \
+    chown -R agent:agent /workspace
+USER agent
+ENV HOME=/home/agent
+ENV PYTHONPATH=/workspace
+RUN git config --global user.email "agent@eval.local" && \
+    git config --global user.name "Comet Native Eval Agent" && \
+    git config --global init.defaultBranch master
+
+CMD ["bash"]

package/eval/local/tasks/comet-native-wave-b-decision-resume/environment/test_wordcount.py

@@ -0,0 +1,27 @@
+"""Baseline tests for the word-count CLI."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run_cli(*args: str, input_text: str) -> str:
+    result = subprocess.run(
+        [sys.executable, "wordcount.py", *args],
+        input=input_text,
+        capture_output=True,
+        text=True,
+        check=True,
+        cwd=Path(__file__).parent,
+    )
+    return result.stdout
+
+
+def test_count_words():
+    assert "Words: 3" in run_cli(input_text="hello world foo")
+
+
+def test_count_lines():
+    output = run_cli("--lines", input_text="hello\nworld\nfoo")
+    assert "Words: 3" in output
+    assert "Lines: 3" in output

package/eval/local/tasks/comet-native-wave-b-decision-resume/environment/wordcount.py

@@ -0,0 +1,36 @@
+"""Simple word count CLI tool."""
+
+import argparse
+import sys
+
+
+def count_words(text: str) -> int:
+    """Count words in text."""
+    return len(text.split())
+
+
+def count_lines(text: str) -> int:
+    """Count lines in text."""
+    return len(text.splitlines())
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Count words and lines in text")
+    parser.add_argument("file", nargs="?", help="Input file (reads stdin if omitted)")
+    parser.add_argument("--lines", action="store_true", help="Also count lines")
+    parser.add_argument("--words", action="store_true", default=True, help="Count words (default)")
+    args = parser.parse_args()
+
+    if args.file:
+        with open(args.file) as source:
+            text = source.read()
+    else:
+        text = sys.stdin.read()
+
+    print(f"Words: {count_words(text)}")
+    if args.lines:
+        print(f"Lines: {count_lines(text)}")
+
+
+if __name__ == "__main__":
+    main()

package/eval/local/tasks/comet-native-wave-b-decision-resume/instruction.md

@@ -0,0 +1,9 @@
+You are working on a Python project named `wordcount-cli`.
+
+Begin by invoking the `/comet-native` Skill. Initialize Native under `docs/comet/`, create one change named `add-unique-counting`, and add a `--unique-words` flag that prints `Unique words: N` while preserving existing word and line behavior. Here, unique means the number of distinct normalized word values, not the number of words that occur exactly once.
+
+Follow Native's Shape requirements before Build. Do not ask for repository facts or implementation choices.
+
+If the user supplies a product decision, record every part of that answer in both the brief and the complete target specification for capability `unique-word-counting`, use Native's explicit confirmation path, and transition to Build. Then end that turn with exactly `COMET_NATIVE_COLD_RESUME_READY` without implementing the feature. The harness will start a new session containing only a continuation request. In that fresh session, re-invoke `/comet-native` before doing any work, then recover the same change from Native state and artifacts on disk. Before any implementation or transition, redirect stdout directly from the named runtime status command to `.cache/comet-native-eval/resume-status.json` exactly once; this is an immutable cold-resume snapshot, so never overwrite or recreate it later, including after Archive. Then implement focused tests and verify. Before invoking either Archive command, create `.cache/comet-native-eval/`. The first Archive dry-run invocation must itself redirect stdout to `.cache/comet-native-eval/archive-preview.json`; a dry-run displayed only in the terminal is invalid and must not be committed. The saved object must be the runtime's complete top-level JSON envelope retaining `command`, `exitCode`, and `data`, not only the preflight data object. Read the preflight hash from that envelope's `data.preflightHash`. The first commit invocation with `--expect-preflight` must itself redirect stdout to `.cache/comet-native-eval/archive-commit.json`. Do not rely on terminal output as saved evidence and do not reconstruct either file after Archive. Before reporting completion, verify all three files exist and contain the runtime's exact complete JSON envelopes.
+
+Do not fabricate, paraphrase, or hand-author runtime JSON evidence. Use only the Comet Native Skill and its bundled runtime; do not create OpenSpec, Classic, `.comet`, or external workflow artifacts.

package/eval/local/tasks/comet-native-wave-b-decision-resume/task.toml

@@ -0,0 +1,40 @@
+[metadata]
+name = "comet-native-wave-b-decision-resume"
+description = "Test one hidden product decision and a context-cleared Native resume from disk"
+difficulty = "hard"
+category = "comet-native"
+tags = ["comet-native", "decision", "cold-resume", "multi-turn", "wave-b"]
+default_treatments = ["COMET_NATIVE_PHASE1"]
+
+[template]
+required = []
+
+[environment]
+description = "Python word-count workspace with only the self-contained Comet Native Skill available."
+dockerfile = "environment/Dockerfile"
+timeout_sec = 900
+
+[validation]
+test_scripts = "test_native_wave_b_decision_resume.py"
+target_artifacts = [".cache/comet-native-eval/resume-status.json", ".cache/comet-native-eval/archive-preview.json", ".cache/comet-native-eval/archive-commit.json", "docs/comet/archive", "docs/comet/specs/unique-word-counting/spec.md"]
+timeout = 120
+
+[evaluation]
+profile = "generic"
+required_skills = ["comet-native"]
+expected_artifacts = [".cache/comet-native-eval/resume-status.json", ".cache/comet-native-eval/archive-preview.json", ".cache/comet-native-eval/archive-commit.json", "docs/comet/archive", "docs/comet/specs/unique-word-counting/spec.md"]
+require_skill_invocation = true
+rubric_criteria = [
+  "Surfaces exactly one user-visible token-normalization decision before Build",
+  "Records the deterministic answer in the brief and complete target specification",
+  "Resumes the same change from disk after context is cleared instead of relying on chat memory",
+  "Implements, verifies, and commits the exact ready Archive preflight with real evidence",
+]
+
+[interaction]
+mode = "auto_user"
+max_turns = 4
+decision_patterns = ["normalization", "punctuation", "apostrophe", "unique word"]
+decision_reply = "Treat words case-insensitively, strip surrounding punctuation, and preserve internal apostrophes."
+continue_prompt = "This is a context-cleared continuation. First invoke `/comet-native` so its recovery contract is loaded. After the Skill loads, the first Bash command, before any Read, Edit, test, or transition, must create .cache/comet-native-eval/ and invoke the bundled runtime command `status add-unique-counting --json`, redirecting its stdout directly to .cache/comet-native-eval/resume-status.json. Confirm that exact envelope names add-unique-counting in Build, and write it exactly once. That file is the immutable cold-resume snapshot: never overwrite or recreate it later, including after Archive. Then re-read the confirmed Native artifacts from disk and continue the same change through Verify and Archive. The first archive dry-run command must include --dry-run --json and redirect stdout directly to .cache/comet-native-eval/archive-preview.json; read data.preflightHash from that exact envelope. The first commit command must include --expect-preflight with that hash and --json, and redirect stdout directly to .cache/comet-native-eval/archive-commit.json. Do not reconstruct either archive envelope after Archive. Verify all three runtime envelopes exist before reporting completion."
+fresh_resume_marker = "COMET_NATIVE_COLD_RESUME_READY"

package/eval/local/tasks/comet-native-wave-b-decision-resume/validation/test_native_wave_b_decision_resume.py

@@ -0,0 +1,208 @@
+"""Validate a confirmed hidden decision and disk-backed Native resume."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+import yaml
+
+from scaffold.python.validation.native_wave import (
+    active_changes,
+    archive_changes,
+    check_archive_transaction,
+    check_cli_feature,
+    check_native_isolation,
+    check_runtime_envelopes,
+    failed,
+    parse_runtime_envelope,
+    passed,
+    write_results,
+)
+
+
+WORKSPACE = Path("/workspace")
+EVIDENCE = Path(".cache/comet-native-eval")
+
+
+def _interaction() -> dict:
+    path = WORKSPACE / "_test_context.json"
+    if not path.is_file():
+        return {}
+    return json.loads(path.read_text(encoding="utf-8")).get("interaction") or {}
+
+
+def check_decision_and_resume() -> dict[str, str]:
+    check = "decision_and_resume"
+    active = active_changes(WORKSPACE)
+    archives = archive_changes(WORKSPACE)
+    if active:
+        return failed(check, f"Expected no active change after Archive, found {len(active)}")
+    if len(archives) != 1:
+        return failed(check, f"Expected exactly one archive, found {len(archives)}")
+
+    archived = archives[0]
+    state_file = archived / "comet-state.yaml"
+    if not state_file.is_file():
+        return failed(check, "Archived comet-state.yaml is missing")
+    try:
+        state = yaml.safe_load(state_file.read_text(encoding="utf-8")) or {}
+    except (OSError, yaml.YAMLError) as error:
+        return failed(check, f"Archived comet-state.yaml is invalid: {error}")
+    expected_state = {
+        "phase": "archive",
+        "approval": "confirmed",
+        "archived": True,
+        "verification_result": "pass",
+    }
+    mismatches = {
+        key: (expected, state.get(key))
+        for key, expected in expected_state.items()
+        if state.get(key) != expected
+    }
+    if mismatches:
+        return failed(check, f"Confirmed terminal state is incomplete: {mismatches}")
+
+    canonical = WORKSPACE / "docs/comet/specs/unique-word-counting/spec.md"
+    decision_files = [
+        archived / "brief.md",
+        archived / "specs/unique-word-counting/spec.md",
+        canonical,
+    ]
+    for path in decision_files:
+        if not path.is_file():
+            return failed(check, f"Decision artifact is missing: {path}")
+        text = path.read_text(encoding="utf-8").lower()
+        case_rule = (
+            "case-insensitive" in text
+            or "lowercase" in text
+            or "case folding" in text
+            or "case-fold" in text
+            or "str.lower" in text
+        )
+        punctuation_rule = (
+            "surrounding punctuation" in text
+            or "leading and trailing punctuation" in text
+            or re.search(
+                r"(?:strip|remove)[^.\n]{0,80}punctuation[^.\n]{0,80}"
+                r"(?:start|beginning|leading)[^.\n]{0,40}(?:end|trailing)",
+                text,
+            )
+            is not None
+        )
+        apostrophe_rule = (
+            "internal apostroph" in text
+            or re.search(r"apostroph(?:e|es)\s+inside", text) is not None
+            or re.search(
+                r"(?:preserve|keep)[^.\n]{0,120}apostroph(?:e|es)"
+                r"[^.\n]{0,80}(?:inside|within)",
+                text,
+            )
+            is not None
+            or (
+                re.search(r"internal\s+punctuation[^.\n]{0,60}(?:preserv|kept|intact)", text)
+                is not None
+                and re.search(
+                    r"apostroph(?:e|es)[^.\n]{0,80}(?:not\s+removed|preserv|kept|intact)",
+                    text,
+                )
+                is not None
+            )
+        )
+        if not (case_rule and punctuation_rule and apostrophe_rule):
+            return failed(check, f"Confirmed normalization decision is incomplete in {path.name}")
+
+    try:
+        resume = parse_runtime_envelope(
+            WORKSPACE / EVIDENCE / "resume-status.json",
+            command="status",
+            exit_code=0,
+        )
+    except ValueError as error:
+        return failed(check, f"Resume status is not an exact Native envelope: {error}")
+    if (
+        resume["data"].get("name") != "add-unique-counting"
+        or resume["data"].get("phase") != "build"
+    ):
+        return failed(
+            check,
+            "Cold resume did not recover add-unique-counting in the exact Build phase",
+        )
+
+    interaction = _interaction()
+    if interaction.get("mode") != "auto_user":
+        return failed(check, "Auto-user interaction metadata is missing")
+    if interaction.get("decision_points") != 1 or interaction.get("deterministic_replies") != 1:
+        return failed(check, "Expected exactly one deterministic decision reply")
+    if interaction.get("fresh_resume_boundaries") != 1:
+        return failed(check, "Expected exactly one new-session cold-resume boundary")
+    turns = interaction.get("actual_turns")
+    maximum = interaction.get("max_turns")
+    if not isinstance(turns, int) or not isinstance(maximum, int) or not (2 <= turns <= maximum):
+        return failed(check, "Cold-resume interaction turn count is invalid")
+
+    try:
+        preview = parse_runtime_envelope(
+            WORKSPACE / EVIDENCE / "archive-preview.json",
+            command="archive --dry-run",
+            exit_code=0,
+        )
+        commit = parse_runtime_envelope(
+            WORKSPACE / EVIDENCE / "archive-commit.json",
+            command="archive",
+            exit_code=0,
+        )
+    except (OSError, ValueError, json.JSONDecodeError) as error:
+        return failed(check, f"Invalid Archive protocol evidence: {error}")
+    preview_data = preview.get("data") if isinstance(preview, dict) else None
+    commit_data = commit.get("data") if isinstance(commit, dict) else None
+    if (
+        preview.get("command") != "archive --dry-run"
+        or preview.get("exitCode") != 0
+        or not isinstance(preview_data, dict)
+        or preview_data.get("ready") is not True
+        or preview_data.get("evidenceFreshness") not in {"complete", "partial"}
+        or preview_data.get("findingCodes") != []
+        or not re.fullmatch(r"[a-f0-9]{64}", str(preview_data.get("preflightHash", "")))
+        or commit.get("command") != "archive"
+        or commit.get("exitCode") != 0
+        or not isinstance(commit_data, dict)
+        or commit_data.get("preflightHash") != preview_data.get("preflightHash")
+    ):
+        return failed(check, "Archive did not commit the exact ready Native preflight")
+    transaction = check_archive_transaction(
+        WORKSPACE,
+        commit_data,
+        "add-unique-counting",
+        preview_data["preflightHash"],
+    )
+    if transaction["status"] != "passed":
+        return failed(check, transaction.get("reason", "Archive transaction is invalid"))
+    return passed(check)
+
+
+def main() -> int:
+    results = [
+        check_cli_feature(
+            WORKSPACE,
+            "--unique-words",
+            "Hello, hello HELLO! can't can't.",
+            "Unique words: 2",
+            "unique",
+        ),
+        check_runtime_envelopes(
+            [
+                WORKSPACE / EVIDENCE / "resume-status.json",
+                WORKSPACE / EVIDENCE / "archive-preview.json",
+                WORKSPACE / EVIDENCE / "archive-commit.json",
+            ]
+        ),
+        check_decision_and_resume(),
+        check_native_isolation(WORKSPACE),
+    ]
+    return write_results(results, WORKSPACE)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/eval/local/tasks/comet-native-wave-c-verification-integrity/environment/Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.12-slim
+
+WORKDIR /workspace
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git nodejs npm ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN npm config set registry https://registry.npmmirror.com && \
+    npm install -g @anthropic-ai/claude-code@latest && \
+    npm config delete registry
+
+RUN pip install --no-cache-dir pyyaml pytest
+
+COPY wordcount.py /workspace/wordcount.py
+COPY test_wordcount.py /workspace/test_wordcount.py
+
+RUN useradd --create-home --shell /bin/bash agent && \
+    chown -R agent:agent /workspace
+USER agent
+ENV HOME=/home/agent
+ENV PYTHONPATH=/workspace
+RUN git config --global user.email "agent@eval.local" && \
+    git config --global user.name "Comet Native Eval Agent" && \
+    git config --global init.defaultBranch master
+
+CMD ["bash"]

package/eval/local/tasks/comet-native-wave-c-verification-integrity/environment/test_wordcount.py

@@ -0,0 +1,27 @@
+"""Baseline tests for the word-count CLI."""
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run_cli(*args: str, input_text: str) -> str:
+    result = subprocess.run(
+        [sys.executable, "wordcount.py", *args],
+        input=input_text,
+        capture_output=True,
+        text=True,
+        check=True,
+        cwd=Path(__file__).parent,
+    )
+    return result.stdout
+
+
+def test_count_words():
+    assert "Words: 3" in run_cli(input_text="hello world foo")
+
+
+def test_count_lines():
+    output = run_cli("--lines", input_text="hello\nworld\nfoo")
+    assert "Words: 3" in output
+    assert "Lines: 3" in output

package/eval/local/tasks/comet-native-wave-c-verification-integrity/environment/wordcount.py

@@ -0,0 +1,36 @@
+"""Simple word count CLI tool."""
+
+import argparse
+import sys
+
+
+def count_words(text: str) -> int:
+    """Count words in text."""
+    return len(text.split())
+
+
+def count_lines(text: str) -> int:
+    """Count lines in text."""
+    return len(text.splitlines())
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Count words and lines in text")
+    parser.add_argument("file", nargs="?", help="Input file (reads stdin if omitted)")
+    parser.add_argument("--lines", action="store_true", help="Also count lines")
+    parser.add_argument("--words", action="store_true", default=True, help="Count words (default)")
+    args = parser.parse_args()
+
+    if args.file:
+        with open(args.file) as source:
+            text = source.read()
+    else:
+        text = sys.stdin.read()
+
+    print(f"Words: {count_words(text)}")
+    if args.lines:
+        print(f"Lines: {count_lines(text)}")
+
+
+if __name__ == "__main__":
+    main()

package/eval/local/tasks/comet-native-wave-c-verification-integrity/instruction.md

@@ -0,0 +1,11 @@
+You are working on a Python project named `wordcount-cli`.
+
+Begin by invoking the `/comet-native` Skill. Initialize Native under `docs/comet/`, create `add-longest-word`, and add a `--longest-word` flag that prints `Longest word: VALUE`. For empty input print `Longest word:` with no value. Preserve the existing counters, add focused tests, and author a complete target specification for capability `longest-word` with at least two identifiable acceptance criteria.
+
+Exercise Native verification integrity rather than jumping straight to Archive:
+
+1. After implementing the feature, leave one unrelated project file outside the declared implementation artifacts. Capture the exact blocked Build `next` envelope (including its prepared partial-scope hash) as `.cache/comet-native-eval/partial-scope.json`. Use that exact hash and Native's explicit confirmed partial-scope path, then run every acceptance check. Advance through Verify with an acceptance-linked report and save the exact Archive dry-run envelope as `.cache/comet-native-eval/partial-archive-preview.json`. It must be fresh `partial` evidence accepted by the explicit allowance, not hand-written partial evidence.
+2. Change a declared implementation artifact after verification. Save the exact Native status envelope showing stale evidence as `.cache/comet-native-eval/stale-status.json`. Save the exact blocked Archive dry-run as `.cache/comet-native-eval/stale-archive-preview.json`, then call Archive with `--expect-preflight` using that preview hash and save the exact exit-73 envelope as `.cache/comet-native-eval/stale-archive-commit.json`. Use Native's evidence-retreat path to return to Build.
+3. Remove the unrelated file, capture a complete implementation scope, rerun all project tests and CLI acceptance checks, and advance through Verify with fresh evidence for every acceptance identifier. Save the exact ready Archive dry-run as `.cache/comet-native-eval/final-archive-preview.json`. Commit Archive with `--expect-preflight` using that exact preview hash and save its exact successful envelope as `.cache/comet-native-eval/archive-commit.json`.
+
+The archived immutable verification envelope and `verification.md` must preserve concrete evidence for every acceptance identifier. Do not fabricate, paraphrase, merge, or hand-author any runtime JSON snapshot. Use only the Comet Native Skill and bundled runtime; do not create OpenSpec, Classic, `.comet`, or external workflow artifacts.

package/eval/local/tasks/comet-native-wave-c-verification-integrity/task.toml

@@ -0,0 +1,36 @@
+[metadata]
+name = "comet-native-wave-c-verification-integrity"
+description = "Test confirmed partial scope, stale evidence retreat, and complete two-step Native Archive"
+difficulty = "hard"
+category = "comet-native"
+tags = ["comet-native", "verification", "freshness", "acceptance-trace", "wave-c"]
+default_treatments = ["COMET_NATIVE_PHASE1"]
+
+[template]
+required = []
+
+[environment]
+description = "Python word-count workspace for exercising Native verification freshness and acceptance traces."
+dockerfile = "environment/Dockerfile"
+timeout_sec = 900
+
+[validation]
+test_scripts = "test_native_wave_c_verification_integrity.py"
+target_artifacts = [".cache/comet-native-eval/partial-scope.json", ".cache/comet-native-eval/partial-archive-preview.json", ".cache/comet-native-eval/stale-status.json", ".cache/comet-native-eval/stale-archive-preview.json", ".cache/comet-native-eval/stale-archive-commit.json", ".cache/comet-native-eval/final-archive-preview.json", ".cache/comet-native-eval/archive-commit.json", "docs/comet/archive", "docs/comet/specs/longest-word/spec.md"]
+timeout = 120
+
+[evaluation]
+profile = "generic"
+required_skills = ["comet-native"]
+expected_artifacts = [".cache/comet-native-eval/partial-scope.json", ".cache/comet-native-eval/partial-archive-preview.json", ".cache/comet-native-eval/stale-status.json", ".cache/comet-native-eval/stale-archive-preview.json", ".cache/comet-native-eval/stale-archive-commit.json", ".cache/comet-native-eval/final-archive-preview.json", ".cache/comet-native-eval/archive-commit.json", "docs/comet/archive", "docs/comet/specs/longest-word/spec.md"]
+require_skill_invocation = true
+rubric_criteria = [
+  "Requires an exact user-confirmed allowance before accepting a partial implementation scope",
+  "Detects post-verification implementation drift and retreats stale evidence back to Build",
+  "Links every acceptance criterion to concrete immutable evidence before Archive",
+  "Uses dry-run plus the exact preflight hash and archives only complete fresh final evidence",
+]
+
+[interaction]
+mode = "none"
+max_turns = 1