@christang/keel 5.3.0 → 5.3.1

package/assets/bootstrap/AGENTS.md

@@ -1,8 +1,8 @@
-<!-- keel:start version=5.3.0 -->
+<!-- keel:start version=5.3.1 -->
 ## Keel Bootstrap
 
 - Start every session with `keel context`; OpenSpec artifacts and Git are the only durable authority — never native memory, goals, or transcripts.
-- Obey the selected task capsule: `keel gate task-start` before implementing, record its fingerprint in the task Evidence `Contract` line, and pass `keel gate task-complete` before checking complete. Touch is the write boundary; on Claude a passing `task-start` guards it by default (`--no-guard`/`keel guard clear` opt out).
+- Obey the selected task capsule: `keel gate task-start` before implementing, record its fingerprint in Evidence `Contract`, and pass `keel gate task-complete` before checking complete. Touch is the write boundary for product files; on Claude a passing `task-start` guards it by default (`--no-guard`/`keel guard clear` opt out).
 - One current agent owns writes; helpers return read-only report/evidence only. No commit, sync, or archive without explicit authorization.
 - Native plugin projections (SessionStart context) are disposable views, never authority; without the plugin or hook, run the commands manually.
 - Keel skills and hooks come from the `keel` native plugin (`codex plugin add` / `claude plugin install`); `keel --init` owns only the OpenSpec schema, overlays, and this bootstrap.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@christang/keel",
   "displayName": "Keel",
   "description": "Keel OpenSpec execution discipline CLI for Claude Code, Codex, and OpenCode.",
-  "version": "5.3.0",
+  "version": "5.3.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/plugins/keel/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.3.0",
+  "version": "5.3.1",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/plugins/keel/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keel",
-  "version": "5.3.0",
+  "version": "5.3.1",
   "description": "Keel OpenSpec execution discipline: stateless continuity, task capsules, deterministic gates, and expectation alignment for Codex and Claude Code.",
   "author": {
     "name": "TanglmChris",

package/scripts/validate_plugin.py

@@ -37,8 +37,8 @@ REQUIRED_SCRIPTS = [
     "scripts/validate_plugin.py",
 ]
 
-PACKAGE_VERSION = "5.3.0"
-PROTOCOL_VERSION = "5.3.0"
+PACKAGE_VERSION = "5.3.1"
+PROTOCOL_VERSION = "5.3.1"
 LEGACY_MANAGED_START = "<!-- keel:start version=2.1 -->"
 OPENSPEC_SCHEMA_NAME = "keel-spec-driven"
 OPENSPEC_CONFIG_PATH = Path("openspec/config.yaml")
@@ -99,7 +99,11 @@ RESIDENT_BLOCKS = [
             "keel gate task-start",
             "task capsule",
             "fingerprint",
-            "Touch is the write boundary",
+            # Prose, not a command: this sentence is the one that has actually
+            # been reworded under byte pressure, so it is matched as a topic —
+            # Touch and a `bound…` word in one statement. The other prose
+            # entries stay literal until one of them needs the same freedom.
+            re.compile(r"Touch\b[^\n]*\bbound", re.IGNORECASE),
             "read-only report/evidence",
             "native plugin",
             "keel --init",
@@ -491,9 +495,9 @@ def strip_template_checksum(content: str) -> tuple[str, str | None]:
     return "".join(kept), checksum
 
 
-def validate_resident_blocks(errors: list[str]) -> None:
+def validate_resident_blocks(errors: list[str], root: Path = ROOT) -> None:
     for block in RESIDENT_BLOCKS:
-        path = ROOT / block["path"]
+        path = root / block["path"]
         if not path.is_file():
             errors.append(f"{block['name']} is missing: {block['path']}")
             continue
@@ -519,9 +523,24 @@ def validate_resident_blocks(errors: list[str]) -> None:
                 f"budget is {max_lines}"
             )
 
+        # A required entry is one of two kinds, and they mean different things.
+        # A literal names a command, marker, or identifier: if the block no
+        # longer contains it exactly, it is telling a reader to run something
+        # that does not exist, so the check must fail. A pattern states a topic
+        # in prose: the concepts must remain, the wording may move — which it
+        # must be free to, because this block is under a line and byte budget
+        # and gets rewritten to fit.
         for required in block["required"]:
-            if required not in managed_block:
-                errors.append(f"{block['name']} missing required topic: {required}")
+            if isinstance(required, str):
+                if required not in managed_block:
+                    errors.append(
+                        f"{block['name']} missing required literal: {required}"
+                    )
+            elif not required.search(managed_block):
+                errors.append(
+                    f"{block['name']} missing required topic: "
+                    f"{required.pattern}"
+                )
 
         lowered = managed_block.lower()
         for forbidden in RESIDENT_FORBIDDEN_SNIPPETS:
@@ -1082,6 +1101,17 @@ def validate_skill_portability_policy_scenario() -> int:
     return 0
 
 
+def posix_paths(text: str) -> str:
+    """Fold path separators so an assertion does not encode the host's spelling.
+
+    Keel prints these paths through the host's path joiner, so the same doctor
+    line reads `.claude\\commands\\opsx` on Windows and `.claude/commands/opsx`
+    on a POSIX runner. Assertions state the forward-slash form and normalize the
+    captured output, rather than branching on the platform or accepting both.
+    """
+    return (text or "").replace("\\", "/")
+
+
 def validate_target_surface_scenario() -> int:
     with tempfile.TemporaryDirectory(prefix="keel-surface-") as raw_tmp:
         tmp = Path(raw_tmp)
@@ -1098,9 +1128,9 @@ def validate_target_surface_scenario() -> int:
             claude_doctor.returncode != 0
             or "Target surface:" not in claude_doctor.stdout
             or "OpenSpec commands: ok" not in claude_doctor.stdout
-            or ".claude\\commands\\opsx" not in claude_doctor.stdout
+            or ".claude/commands/opsx" not in posix_paths(claude_doctor.stdout)
             or "OpenSpec action skills: ok" not in claude_doctor.stdout
-            or ".claude\\skills" not in claude_doctor.stdout
+            or ".claude/skills" not in posix_paths(claude_doctor.stdout)
             or "bootstrap: ok" not in claude_doctor.stdout
             or "CLAUDE import: ok" not in claude_doctor.stdout
             or "native plugin runtime: manual" not in claude_doctor.stdout
@@ -1130,9 +1160,9 @@ def validate_target_surface_scenario() -> int:
         if (
             codex_doctor.returncode != 0
             or "OpenSpec commands: ok" not in codex_doctor.stdout
-            or codex_prompt_dir not in codex_doctor.stdout
+            or posix_paths(codex_prompt_dir) not in posix_paths(codex_doctor.stdout)
             or "OpenSpec action skills: ok" not in codex_doctor.stdout
-            or ".codex\\skills" not in codex_doctor.stdout
+            or ".codex/skills" not in posix_paths(codex_doctor.stdout)
             or "bootstrap: ok" not in codex_doctor.stdout
             or "native plugin runtime: manual" not in codex_doctor.stdout
             or "Target capabilities (codex):" not in codex_doctor.stdout
@@ -1173,9 +1203,9 @@ def validate_target_surface_scenario() -> int:
         if (
             opencode_doctor.returncode != 0
             or "OpenSpec commands: ok" not in opencode_doctor.stdout
-            or ".opencode\\commands" not in opencode_doctor.stdout
+            or ".opencode/commands" not in posix_paths(opencode_doctor.stdout)
             or "OpenSpec action skills: ok" not in opencode_doctor.stdout
-            or ".opencode\\skills" not in opencode_doctor.stdout
+            or ".opencode/skills" not in posix_paths(opencode_doctor.stdout)
             or "bootstrap: ok" not in opencode_doctor.stdout
             or "native plugin: manual" not in opencode_doctor.stdout
             or "Target capabilities (opencode):" not in opencode_doctor.stdout
@@ -7024,8 +7054,11 @@ def validate_native_plugin_marketplaces_scenario() -> int:
     codex = shutil.which("codex")
     claude = claude_cli()
     if codex is None or claude is None:
-        report("native-plugin-marketplaces requires codex and claude CLIs.")
-        return 1
+        return skip_scenario(
+            "native-plugin-marketplaces",
+            "requires the codex and claude CLIs, which are not installed; it "
+            "probes native marketplace behavior no CI runner provides",
+        )
 
     with tempfile.TemporaryDirectory(prefix="keel-native-market-") as raw_tmp:
         tmp = Path(raw_tmp)
@@ -10129,8 +10162,11 @@ def validate_native_plugin_install_matrix_scenario() -> int:
     codex = shutil.which("codex")
     claude = claude_cli()
     if codex is None or claude is None:
-        report("native-plugin-install-matrix requires codex and claude CLIs.")
-        return 1
+        return skip_scenario(
+            "native-plugin-install-matrix",
+            "requires the codex and claude CLIs, which are not installed; it "
+            "probes native install behavior no CI runner provides",
+        )
 
     expected_version = json.loads(
         (ROOT / "package.json").read_text(encoding="utf-8")
@@ -10415,6 +10451,335 @@ def mode_fixture_tasks(mode: str, touch: str) -> str:
     )
 
 
+def validate_runner_skip_accounting_scenario() -> int:
+    """Issue #10: the suite could not pass anywhere the native CLIs are absent.
+
+    Two of seventy scenarios probe native runtimes and used to `return 1` when
+    the CLI was missing, so no CI runner could ever go green. A skip must be
+    reported and counted, never conflated with a pass or a failure.
+    """
+    label = "runner-skip-accounting"
+    runner = str(ROOT / "scripts/validate_plugin.py")
+
+    def run_registry(results: str) -> subprocess.CompletedProcess[str]:
+        """Drive run_all over synthetic scenario results in a child process.
+
+        run_all dispatches each scenario as its own subprocess, which reads the
+        real registry from disk, so a substituted registry would be ignored.
+        The accounting is the behavior under test, so the process fan-out is
+        replaced with fixed (name, code, output) triples instead.
+        """
+        program = (
+            "import sys\n"
+            f"src = open({runner!r}, encoding='utf-8').read()\n"
+            "ns = {'__name__': 'v', '__file__': %r}\n" % runner
+            + "exec(compile(src, %r, 'exec'), ns)\n" % runner
+            + f"results = {results}\n"
+            "ns['SCENARIOS'] = tuple((n, None) for n, _, _ in results)\n"
+            "ns['run_baseline'] = lambda: 0\n"
+            "ns['run_scenario_processes'] = lambda names, jobs: results\n"
+            "sys.exit(ns['run_all'](2))\n"
+        )
+        return subprocess.run(
+            [sys.executable, "-c", program],
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            cwd=str(ROOT),
+        )
+
+    # A skipping scenario must not fail the run, must be named, and must be
+    # excluded from the verified count; a failing one must still fail it.
+    both = run_registry(
+        "[('fake-skip', 3, 'fake-skip scenario skipped: the frob CLI\\n'),"
+        " ('fake-pass', 0, 'fake-pass scenario passed.\\n')]"
+    )
+    out = (both.stdout or "") + (both.stderr or "")
+    if both.returncode != 0:
+        report(f"{label}: a skipping scenario must not fail the run.")
+        report(out.strip())
+        return 1
+    for needle in ("fake-skip", "skipped", "the frob CLI", "plus 1 scenario"):
+        if needle not in out:
+            report(f"{label}: the summary must report {needle!r}; got:\n{out.strip()}")
+            return 1
+    if "fake-pass" in out.split("passed:")[-1]:
+        report(f"{label}: a passing scenario must not be listed as skipped.")
+        report(out.strip())
+        return 1
+
+    mixed = run_registry(
+        "[('fake-skip', 3, 'fake-skip scenario skipped: the frob CLI\\n'),"
+        " ('fake-fail', 1, 'fake-fail scenario failed.\\n')]"
+    )
+    mixed_out = (mixed.stdout or "") + (mixed.stderr or "")
+    if mixed.returncode == 0 or "failed for: fake-fail" not in mixed_out:
+        report(
+            f"{label}: a skip beside a failure must still fail the run and name "
+            "the failure."
+        )
+        report(mixed_out.strip())
+        return 1
+    if "fake-skip" in mixed_out.split("failed for:")[-1]:
+        report(f"{label}: a skipped scenario must not be named as a failure.")
+        report(mixed_out.strip())
+        return 1
+
+    # The two real native-runtime scenarios must take the skip path, not fail,
+    # when their CLI cannot be resolved.
+    for name in ("native-plugin-marketplaces", "native-plugin-install-matrix"):
+        blinded = subprocess.run(
+            [sys.executable, runner, "--scenario", name],
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            cwd=str(ROOT),
+            env={**os.environ, "PATH": str(ROOT), "PATHEXT": ""},
+        )
+        blinded_out = (blinded.stdout or "") + (blinded.stderr or "")
+        if blinded.returncode != 3 or "skipped" not in blinded_out:
+            report(
+                f"{label}: {name} must exit 3 with a reported skip when its CLI "
+                f"cannot be resolved; got {blinded.returncode}."
+            )
+            report(blinded_out.strip())
+            return 1
+        if "codex" not in blinded_out:
+            report(f"{label}: {name}'s skip does not name the runtime it needed.")
+            report(blinded_out.strip())
+            return 1
+
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
+def sibling_scope_tasks(sibling_checked: bool, sibling_touch: str) -> str:
+    """Two tasks: 1.1 owns `shared.js`, 1.2 is the one being completed."""
+
+    def task(task_id: str, title: str, checked: bool, touch: str) -> str:
+        mark = "x" if checked else " "
+        return (
+            f"- [{mark}] {task_id} {title}\n"
+            "  - Covers:\n"
+            "    - E1: public behavior\n"
+            "  - Touch:\n"
+            + "".join(f"    - {entry}\n" for entry in touch.split(","))
+            + "  - Verify:\n"
+            "    - Strategy: evidence-first\n"
+            "    - M1: node test.js\n"
+            "  - Evidence:\n"
+            "    - M1: verified\n"
+            "    - Review:\n"
+            "      - Status: pass\n"
+            "      - Acceptance check: reviewed\n"
+            "      - Scope check: reviewed\n"
+            "      - Findings: none\n"
+            "    - Blocker: none\n"
+        )
+
+    return (
+        "# Tasks\n\n"
+        "## 1. Work\n\n"
+        + task("1.1", "Own the shared file", sibling_checked, sibling_touch)
+        + "\n"
+        + task("1.2", "Own its own file", False, "src/mine.js")
+        + "\n## Expectation Coverage\n\n- None.\n"
+    )
+
+
+def validate_completed_sibling_attribution_scenario() -> int:
+    """Issue #13 item 2: a finished task's uncommitted work blamed the next one.
+
+    `--base HEAD` cannot tell who wrote a path, so a sibling that already passed
+    its own completion gate had its files attributed to whoever ran next. The
+    workaround — commit per task — was correct but implicit, and the diagnostic
+    named a file the author never touched.
+    """
+    label = "completed-sibling-attribution"
+
+    def complete(sibling_checked: bool, sibling_touch: str = "src/shared.js"):
+        with tempfile.TemporaryDirectory(prefix="keel-sibling-scope-") as raw:
+            repo = Path(raw)
+            for name in ("src/shared.js", "src/mine.js", "src/stray.js"):
+                write_text(repo / name, "// base\n")
+            write_text(
+                repo / "openspec/changes/demo/tasks.md",
+                sibling_scope_tasks(sibling_checked, sibling_touch),
+            )
+            for args in (
+                ["init", "--quiet"],
+                ["-c", "user.email=t@e", "-c", "user.name=t", "add", "-A"],
+                [
+                    "-c", "user.email=t@e", "-c", "user.name=t",
+                    "commit", "--quiet", "-m", "base",
+                ],
+            ):
+                done = subprocess.run(
+                    ["git", *args], cwd=repo, capture_output=True, text=True
+                )
+                if done.returncode != 0:
+                    report(f"{label}: git {args[0]} failed: {done.stderr}")
+                    return None
+            # The sibling's work and an undeclared stray, both uncommitted.
+            write_text(repo / "src/shared.js", "// sibling's uncommitted work\n")
+            write_text(repo / "src/stray.js", "// nobody declared this\n")
+            result = run_keel(
+                repo, "gate", "task-complete",
+                "--change", "demo", "--task", "1.2", "--base", "HEAD", "--json",
+            )
+            return json.loads(result.stdout) if result.stdout else {}
+
+    owned = complete(sibling_checked=True)
+    if owned is None:
+        return 1
+    outside = [
+        item.get("message", "")
+        for item in owned.get("problems", [])
+        if item.get("code") == "outside-touch"
+    ]
+    if any("src/shared.js" in message for message in outside):
+        report(
+            f"{label}: a completed sibling's declared file was still attributed "
+            f"to the selected task: {outside}"
+        )
+        return 1
+    if not any("src/stray.js" in message for message in outside):
+        report(
+            f"{label}: a path no task declares must still fail: {outside}"
+        )
+        return 1
+    warnings = " ".join(owned.get("warnings", []))
+    if "src/shared.js" not in warnings or "1.1" not in warnings:
+        report(
+            f"{label}: the exclusion must be reported, naming the path and the "
+            f"completed task that declares it; got {owned.get('warnings')}"
+        )
+        return 1
+
+    unchecked = complete(sibling_checked=False)
+    if unchecked is None:
+        return 1
+    unchecked_outside = [
+        item.get("message", "")
+        for item in unchecked.get("problems", [])
+        if item.get("code") == "outside-touch"
+    ]
+    if not any("src/shared.js" in message for message in unchecked_outside):
+        report(
+            f"{label}: an unchecked sibling's Touch must grant nothing: "
+            f"{unchecked_outside}"
+        )
+        return 1
+
+    no_touch = complete(sibling_checked=True, sibling_touch="none")
+    if no_touch is None:
+        return 1
+    none_outside = [
+        item.get("message", "")
+        for item in no_touch.get("problems", [])
+        if item.get("code") == "outside-touch"
+    ]
+    if not any("src/shared.js" in message for message in none_outside):
+        report(
+            f"{label}: a sibling whose Touch is none must contribute no claim: "
+            f"{none_outside}"
+        )
+        return 1
+
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
+def validate_resident_topic_matching_scenario() -> int:
+    """Issue #15 item 1: required entries were named topics, matched as prose.
+
+    The bootstrap is under a line and byte budget, so its wording gets rewritten
+    to fit — and every rewrite of a pinned sentence failed the check that was
+    supposed to prove only that the topic was still covered.
+    """
+    label = "resident-topic-matching"
+    source = (ROOT / "assets/bootstrap/AGENTS.md").read_text(encoding="utf-8")
+    original = "Touch is the write boundary for product files;"
+    if original not in source:
+        report(
+            f"{label}: the fixture's anchor sentence is not in the bootstrap; "
+            "update this scenario alongside the wording."
+        )
+        return 1
+
+    def errors_for(text: str) -> list[str]:
+        with tempfile.TemporaryDirectory(prefix="keel-resident-topic-") as raw:
+            root = Path(raw)
+            write_text(root / "assets/bootstrap/AGENTS.md", text)
+            found: list[str] = []
+            validate_resident_blocks(found, root)
+            return found
+
+    def touch_errors(text: str) -> list[str]:
+        return [item for item in errors_for(text) if "Touch" in item or "bound" in item]
+
+    baseline = errors_for(source)
+    if baseline:
+        report(f"{label}: the unmodified bootstrap must pass: {baseline}")
+        return 1
+
+    # A rewording that keeps both concepts in one statement must pass.
+    reworded = source.replace(
+        original, "Touch bounds product writes, not the task's own records;"
+    )
+    if touch_errors(reworded):
+        report(
+            f"{label}: a rewording that keeps the topic was rejected: "
+            f"{touch_errors(reworded)}"
+        )
+        return 1
+
+    # Deleting the statement must still fail.
+    deleted = source.replace(original, "")
+    if not touch_errors(deleted):
+        report(f"{label}: deleting the boundary statement did not fail the check.")
+        return 1
+
+    # Mentioning only one of the topic's words must not satisfy it.
+    partial = source.replace(original, "Touch the files you declared;")
+    if not touch_errors(partial):
+        report(
+            f"{label}: a statement mentioning only Touch, with no boundary "
+            "concept, satisfied the topic."
+        )
+        return 1
+
+    # A renamed command must still fail, and be reported as a literal.
+    renamed = source.replace("keel context", "keel status")
+    literal_errors = [item for item in errors_for(renamed) if "keel context" in item]
+    if not literal_errors:
+        report(f"{label}: renaming a required command did not fail the check.")
+        return 1
+    if not any("literal" in item for item in literal_errors):
+        report(
+            f"{label}: a missing command must be reported as a missing literal, "
+            f"distinguishably from a missing topic: {literal_errors}"
+        )
+        return 1
+    if any("literal" in item for item in touch_errors(deleted)):
+        report(
+            f"{label}: a missing topic must not be reported as a missing "
+            f"literal: {touch_errors(deleted)}"
+        )
+        return 1
+
+    if (ROOT / "assets/bootstrap/AGENTS.md").read_text(encoding="utf-8") != source:
+        report(f"{label}: the shipped bootstrap was left modified.")
+        return 1
+    if label not in {name for name, _ in SCENARIOS}:
+        report(f"{label}: the scenario registry does not include it.")
+        return 1
+    report(f"{label} scenario passed.")
+    return 0
+
+
 def validate_repo_action_mode_scenario() -> int:
     """Issue #8 example 2: a repository action had no legal contract.
 
@@ -11603,6 +11968,33 @@ def validate_validation_runner_scenario() -> int:
         report("validation-runner: README does not document the parallel runner.")
         return 1
 
+    # The full gate must actually run somewhere other than one author's machine:
+    # a workflow drives the same single entry point on push and pull request,
+    # and the release workflow keeps its own tag guard rather than becoming the
+    # suite's only runner.
+    workflow_path = ROOT / ".github/workflows/test.yml"
+    if not workflow_path.is_file():
+        report(
+            "validation-runner: no .github/workflows/test.yml, so the full gate "
+            "runs only in the local pre-push hook."
+        )
+        return 1
+    workflow = workflow_path.read_text(encoding="utf-8")
+    for needle in ("npm test", "npm ci", "pull_request", "push:", "ubuntu-latest"):
+        if needle not in workflow:
+            report(
+                "validation-runner: the full-gate workflow does not declare "
+                f"{needle!r}."
+            )
+            report(workflow)
+            return 1
+    publish = (ROOT / ".github/workflows/publish.yml").read_text(encoding="utf-8")
+    if "does not match package.json version" not in publish:
+        report(
+            "validation-runner: the release workflow lost its tag/version guard."
+        )
+        return 1
+
     # Behavioral: the parallel machinery preserves registry order, keeps a
     # passing scenario's buffered output, and fails loudly on a bad entry.
     ordered = run_scenario_processes(
@@ -11752,6 +12144,12 @@ SCENARIOS: tuple = (
     ("touch-write-guard", validate_touch_write_guard_scenario),
     ("touch-guard-record-layer", validate_touch_guard_record_layer_scenario),
     ("repo-action-mode", validate_repo_action_mode_scenario),
+    ("runner-skip-accounting", validate_runner_skip_accounting_scenario),
+    ("resident-topic-matching", validate_resident_topic_matching_scenario),
+    (
+        "completed-sibling-attribution",
+        validate_completed_sibling_attribution_scenario,
+    ),
     ("touch-guard-drift", validate_touch_guard_drift_scenario),
     ("touch-guard-surface", validate_touch_guard_surface_scenario),
     ("plugin-compaction-continuity", validate_plugin_compaction_continuity_scenario),
@@ -11868,6 +12266,19 @@ def validate_archive_overlay_hygiene(errors: list[str]) -> None:
         )
 
 
+# Exit code 3 means "this scenario did not run because an external runtime it
+# probes is absent". 0 is pass, 1 is fail, 2 is an unknown scenario or a usage
+# error, so conflating an unavailable runtime with either would hide both. The
+# reason is narrow on purpose: an inconvenient assertion, a hard fixture, or a
+# platform difference is a failure, never a skip.
+SKIPPED = 3
+
+
+def skip_scenario(label: str, reason: str) -> int:
+    report(f"{label} scenario skipped: {reason}")
+    return SKIPPED
+
+
 def run_baseline() -> int:
     errors: list[str] = []
     validate_manifest(errors)
@@ -11899,19 +12310,29 @@ def run_all(jobs: int) -> int:
     # completion, buffered output is replayed in registry order, and every
     # failure is named in one summary.
     failures = []
+    skipped = []
     if run_baseline() != 0:
         failures.append("baseline")
     ordered = run_scenario_processes([name for name, _ in SCENARIOS], jobs)
     for name, code, output in ordered:
         sys.stdout.write(output)
-        if code != 0:
+        if code == SKIPPED:
+            skipped.append(name)
+        elif code != 0:
             failures.append(name)
     if failures:
         report(f"validation --all failed for: {', '.join(failures)}")
         return 1
-    report(
-        f"validation --all passed: baseline plus {len(SCENARIOS)} scenarios."
+    # The verified count excludes skips, so the number that lands in evidence is
+    # the number actually run, and every skip is named with the run.
+    verified = len(SCENARIOS) - len(skipped)
+    summary = (
+        f"validation --all passed: baseline plus {verified} "
+        f"scenario{'' if verified == 1 else 's'}"
     )
+    if skipped:
+        summary += f", {len(skipped)} skipped: {', '.join(skipped)}"
+    report(f"{summary}.")
     return 0
 
 

package/src/core/gates.js

@@ -316,7 +316,30 @@ function pathAllowed(candidate, touch) {
   });
 }
 
-function scopeEvidence(repo, task, base, contract = null, change = null) {
+// A base comparison shows that a path changed, never who changed it. When a
+// task of the same change is already checked complete and declares the path in
+// its own Touch, blaming the selected task is a guess — and the wrong one often
+// enough that the per-task commit habit became an implicit requirement whose
+// diagnostic named a file the author never touched. Only a checked sibling
+// counts: an unchecked task's Touch is a plan, not a record.
+function completedSiblingOwners(tasks, selected) {
+  const owners = [];
+  for (const item of tasks || []) {
+    if (item.id === selected.id || !item.checked) continue;
+    const declared = touchEntries(item);
+    if (declared.length > 0) owners.push({ id: item.id, touch: declared });
+  }
+  return owners;
+}
+
+function scopeEvidence(
+  repo,
+  task,
+  base,
+  contract = null,
+  change = null,
+  tasks = null
+) {
   const dirtyPaths = gitPaths(repo);
   if (!base) {
     return {
@@ -358,17 +381,35 @@ function scopeEvidence(repo, task, base, contract = null, change = null) {
   // attributed as outside Touch. Other changes' directories, the archive tree,
   // and the specs/schemas trees stay attributable.
   const authoringPrefix = change ? `openspec/changes/${change}/` : null;
-  const outside = [...changed]
+  const owners = completedSiblingOwners(tasks, task);
+  const warnings = [];
+  const outside = [];
+  const candidates = [...changed]
     .map((item) => item.replace(/\\/g, "/"))
     .filter((item) => item !== "keel/guard.json")
     .filter((item) => !(authoringPrefix && item.startsWith(authoringPrefix)))
     .filter((item) => !pathAllowed(item, touch))
     .sort();
+  for (const item of candidates) {
+    const owner = owners.find((entry) => pathAllowed(item, entry.touch));
+    if (owner) {
+      // Reported, not silent: the comparison could not establish authorship,
+      // and resolving that in the selected task's favour is a judgment the
+      // author should see rather than a fact the gate discovered.
+      warnings.push(
+        `${item} is not attributed to this task: task ${owner.id} of the same `
+          + "change is checked complete and declares it in Touch. A base "
+          + "comparison cannot establish which task wrote it."
+      );
+      continue;
+    }
+    outside.push(item);
+  }
   return {
     problems: outside.map((item) =>
       problem("outside-touch", `Changed path is outside Touch: ${item}`)
     ),
-    warnings: [],
+    warnings,
   };
 }
 
@@ -481,7 +522,8 @@ function taskComplete(repo, options) {
     task,
     options.base,
     usableContract,
-    selection.change
+    selection.change,
+    selection.tasks
   );
   checks.problems.push(...scope.problems);
   const status =