From 90c851cd5af9991f20f4f06b7629e8136384269c Mon Sep 17 00:00:00 2001
From: baskduf <baskduf@gmail.com>
Date: Sat, 6 Jun 2026 23:35:44 +0900
Subject: [PATCH] Validate make and just command references

---
 ROADMAP.md                                    |   6 +-
 ...ink-failure-memory-to-regression-checks.md |  16 +-
 .../005-make-just-command-validation.yaml     |  78 +++++
 scripts/check_effectiveness_plan.py           | 156 +++++++++-
 scripts/check_failure_memory.py               | 124 +++++++-
 .../scripts/check_effectiveness_plan.py       | 156 +++++++++-
 .../generic/scripts/check_failure_memory.py   | 124 +++++++-
 tests/test_check_effectiveness_plan.py        | 282 ++++++++++++++++++
 tests/test_check_failure_memory.py            | 150 ++++++++++
 9 files changed, 1075 insertions(+), 17 deletions(-)
 create mode 100644 docs/examples/task-outcomes/005-make-just-command-validation.yaml

diff --git a/ROADMAP.md b/ROADMAP.md
index f0c9100..a88f722 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -106,9 +106,9 @@ guidance, Next.js App Router notes, failure-memory verification, decision-memory
 warnings, deterministic behavior gate placement, and trigger-based task outcome
 evidence. Useful next additions include:
 
-- command existence validation for `make`, `just`, Maven, Gradle, Go, and other
-  profile-relevant task runners referenced by failure-memory or effectiveness
-  records
+- command existence validation beyond package scripts, root `make` targets, and
+  root `just` recipes for Maven, Gradle, Go, and other profile-relevant task
+  runners referenced by failure-memory or effectiveness records
 - more fixture-backed examples for provider-specific request shape, response
   envelopes, redaction, zero-result behavior, and provider errors
 - clearer ADR and failure-record boundary examples for small changes so
diff --git a/docs/decisions/0004-link-failure-memory-to-regression-checks.md b/docs/decisions/0004-link-failure-memory-to-regression-checks.md
index 1808c1d..764d789 100644
--- a/docs/decisions/0004-link-failure-memory-to-regression-checks.md
+++ b/docs/decisions/0004-link-failure-memory-to-regression-checks.md
@@ -78,17 +78,21 @@ post-push, or unknown.
   JavaScript package scripts and avoids passing a root command only because a
   nested workspace package has the same script, but it still does not prove that
   the script asserts the specific failure axis.
+- Root `make target` and `just recipe` checks are verified against checked-in
+  root Makefile variants and justfile variants. This closes the same
+  fake-command gap for common task-runner commands, but it still does not parse
+  included makefiles, option-heavy invocations such as `make -C app check`, or
+  prove that the target asserts the specific failure axis.
 - Other command-shaped checks are still recognized mostly by shape. The checker
-  does not yet verify that `make`, `just`, Python module commands, Gradle,
-  Maven, Go, Rust, .NET, or other task-runner commands exist in the target
-  configuration.
+  does not yet verify that Python module commands, Gradle, Maven, Go, Rust,
+  .NET, or other task-runner commands exist in the target configuration.
 - Monorepo and workspace-specific commands need explicit target adaptation when
   the intended command is not runnable from the repository root.
 - Detection-link validation is regex-based. It blocks known non-committal
   phrases, but future wording may require additional test cases.
-- Generic command coverage is still biased toward common JavaScript and Python
-  commands. Add explicit coverage before relying on this gate for Go, Rust,
-  Java, .NET, or Gradle-heavy targets.
+- Generic command coverage is still biased toward common JavaScript, Make,
+  Just, and Python-shaped commands. Add explicit coverage before relying on
+  this gate for Go, Rust, Java, .NET, or Gradle-heavy targets.
 - Target repositories with pre-existing non-kit `docs/failures/*.md` schemas
   may need adoption-specific adaptation instead of blindly applying the generic
   checker.
diff --git a/docs/examples/task-outcomes/005-make-just-command-validation.yaml b/docs/examples/task-outcomes/005-make-just-command-validation.yaml
new file mode 100644
index 0000000..7bdc242
--- /dev/null
+++ b/docs/examples/task-outcomes/005-make-just-command-validation.yaml
@@ -0,0 +1,78 @@
+schema_version: 1
+
+target:
+  repository: baskduf/harness-starter-kit
+  repository_ref: codex/make-just-command-validation working tree based on e98b6f40f134bcacbab0bb9cb12178f1e071bb63
+  stack_or_framework: Python and Markdown harness kit
+  date: 2026-06-06
+  agent_or_model: Codex
+  reviewer: Codex primary agent plus read-only subagent reviewer
+
+task:
+  id: make-just-command-validation
+  run_id: harness-starter-kit-005
+  prompt_summary: Extend command existence validation for root make targets and just recipes.
+  prompt_ref: current Codex thread request to proceed with option 1 and review findings until resolved
+  prompt_hash: not recorded
+  comparable_task_group: harness-maintenance
+  condition: harnessed-only
+  expected_boundary:
+    - ROADMAP.md
+    - docs/decisions/0004-link-failure-memory-to-regression-checks.md
+    - docs/examples/task-outcomes/**
+    - scripts/check_effectiveness_plan.py
+    - scripts/check_failure_memory.py
+    - templates/generic/scripts/check_effectiveness_plan.py
+    - templates/generic/scripts/check_failure_memory.py
+    - tests/test_check_effectiveness_plan.py
+    - tests/test_check_failure_memory.py
+    - tests/test_repository_hygiene.py
+  known_failure_mode: Failure memory or task outcome evidence can cite fake make or just commands that look concrete but are not declared in the target repository.
+
+harness_context:
+  harness_doctor_score: previously 98/100, not treated as effectiveness proof
+  harness_source:
+    kit_url: https://github.com/baskduf/harness-starter-kit
+    kit_commit: e98b6f40f134bcacbab0bb9cb12178f1e071bb63
+    source_tracking_ref: none; this repository is the kit source
+  relevant_instructions:
+    - AGENTS.md
+    - docs/decisions/0004-link-failure-memory-to-regression-checks.md
+    - ROADMAP.md
+  relevant_constraints:
+    - python3 -m unittest tests.test_check_failure_memory tests.test_check_effectiveness_plan tests.test_repository_hygiene
+    - python3 -m py_compile scripts/check_failure_memory.py scripts/check_effectiveness_plan.py templates/generic/scripts/check_failure_memory.py templates/generic/scripts/check_effectiveness_plan.py
+    - python3 scripts/check_effectiveness_plan.py
+    - python3 scripts/check_failure_memory.py
+  relevant_memory_records:
+    - docs/decisions/0004-link-failure-memory-to-regression-checks.md
+    - docs/decisions/0006-trigger-task-outcome-evidence-for-substantial-harness-work.md
+    - docs/failures/0005-failure-memory-was-not-linked-to-regression-checks.md
+    - docs/failures/0007-dogfood-first-pass-failures-lacked-memory-decision.md
+
+outcome:
+  files_changed:
+    - ROADMAP.md
+    - docs/decisions/0004-link-failure-memory-to-regression-checks.md
+    - docs/examples/task-outcomes/005-make-just-command-validation.yaml
+    - scripts/check_effectiveness_plan.py
+    - scripts/check_failure_memory.py
+    - templates/generic/scripts/check_effectiveness_plan.py
+    - templates/generic/scripts/check_failure_memory.py
+    - tests/test_check_effectiveness_plan.py
+    - tests/test_check_failure_memory.py
+  wrong_file_edits: 0
+  repeated_known_mistake: false
+  verification_command: python3 -m unittest tests.test_check_failure_memory tests.test_check_effectiveness_plan tests.test_repository_hygiene && python3 -m py_compile scripts/check_failure_memory.py scripts/check_effectiveness_plan.py templates/generic/scripts/check_failure_memory.py templates/generic/scripts/check_effectiveness_plan.py
+  first_pass_verification:
+    result: failed_then_passed
+  drift_violations_detected: []
+  human_rework_minutes: 0
+  reverted_files: []
+  notes: The validation is intentionally scoped to root Makefile and justfile variants; option-heavy or included-file task runners remain follow-up scope. Primary-agent review fixed a test assertion indentation issue; subagent review found and the final loop fixed task-outcome false-inclusion validation, GNU makefile precedence, make variable assignments including dotted values, just default-parameter parsing, and an inline-code backtick regex miss before final validation.
+
+follow_up:
+  harness_change_needed: false
+  decision_or_failure_record: docs/decisions/0004-link-failure-memory-to-regression-checks.md; no failure record because this closed a known validation gap rather than fixing a recurring failed check from this run.
+  include_in_effectiveness_report: false
+  include_in_comparable_product_task_count: false
diff --git a/scripts/check_effectiveness_plan.py b/scripts/check_effectiveness_plan.py
index 2ebed19..aa0f72c 100644
--- a/scripts/check_effectiveness_plan.py
+++ b/scripts/check_effectiveness_plan.py
@@ -97,7 +97,11 @@
     re.compile(r"\b(?:tests?|specs?|fixtures?|scripts?)/[^\s,.;)]+"),
     re.compile(r"`?\.github/workflows/[^\s,.;)`]+`?"),
     re.compile(r"\b(?:npm|pnpm|yarn|bun)\s+run\s+[\w:./-]+"),
-    re.compile(r"\b(?:make|just)\s+[\w:./-]+"),
+    re.compile(
+        r"\bmake(?:\s+[\w.-]+=[^\s,;)`\]}]+)*\s+(?!-)[\w:./-]+"
+        r"(?=$|[\s,.;)`\]}])"
+    ),
+    re.compile(r"\bjust\s+(?!-)[\w:./-]+"),
     re.compile(r"\bpython3?\s+(?:-m\s+[\w.:-]+|scripts?/[^\s,.;)]+)"),
     re.compile(r"\bpytest\s+(?:-[\w-]+|tests?/[^\s,.;)]+|[\w/.-]+)"),
     re.compile(r"\b(?:vitest|jest|ruff|mypy|eslint)\s+[\w/.:@-]+"),
@@ -116,6 +120,13 @@
 PACKAGE_SCRIPT_COMMAND_RE = re.compile(
     r"\b(?P<manager>npm|pnpm|yarn|bun)\s+run\s+(?P<script>[\w:./-]+)"
 )
+MAKE_COMMAND_RE = re.compile(
+    r"\bmake(?:\s+[\w.-]+=[^\s,;)`\]}]+)*\s+(?!-)(?P<target>[\w:./-]+)"
+    r"(?=$|[\s,.;)`\]}])"
+)
+JUST_COMMAND_RE = re.compile(r"\bjust\s+(?!-)(?P<recipe>[\w:./-]+)")
+MAKEFILE_NAMES = ("GNUmakefile", "makefile", "Makefile")
+JUSTFILE_NAMES = ("justfile", "Justfile", ".justfile")
 
 FAILURE_RECORD_RE = re.compile(
     r"`?(docs/failures/[^\s,;)`]+)`?",
@@ -429,6 +440,10 @@ def normalize_package_script(value: str) -> str:
     return value.rstrip(".,;)]}")
 
 
+def normalize_command_target(value: str) -> str:
+    return value.rstrip(".,;)]}")
+
+
 def root_package_scripts(root: Path) -> set[str]:
     package_json = root / "package.json"
     if not package_json.exists():
@@ -443,6 +458,71 @@ def root_package_scripts(root: Path) -> set[str]:
     return {str(name) for name in package_scripts}
 
 
+def root_make_targets(root: Path) -> set[str]:
+    targets: set[str] = set()
+    path = next(
+        (root / name for name in MAKEFILE_NAMES if (root / name).exists()),
+        None,
+    )
+    if path is None:
+        return targets
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except (OSError, UnicodeDecodeError):
+        return targets
+    for raw_line in lines:
+        if not raw_line or raw_line[:1].isspace():
+            continue
+        line = raw_line.split("#", 1)[0].rstrip()
+        if ":" not in line:
+            continue
+        target_part, rule_part = line.split(":", 1)
+        if not target_part.strip() or "=" in target_part:
+            continue
+        if rule_part.lstrip().startswith("="):
+            continue
+        for target in target_part.split():
+            if target and "%" not in target and not target.startswith("."):
+                targets.add(target)
+    return targets
+
+
+def root_just_recipes(root: Path) -> set[str]:
+    recipes: set[str] = set()
+    for name in JUSTFILE_NAMES:
+        path = root / name
+        if not path.exists():
+            continue
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except (OSError, UnicodeDecodeError):
+            continue
+        for raw_line in lines:
+            if not raw_line or raw_line[:1].isspace():
+                continue
+            line = raw_line.split("#", 1)[0].rstrip()
+            alias_match = re.match(r"alias\s+(?P<name>[\w.-]+)\s*:=", line)
+            if alias_match is not None:
+                recipes.add(alias_match.group("name"))
+                continue
+            if ":" not in line:
+                continue
+            recipe_part, rule_part = line.split(":", 1)
+            if not recipe_part.strip():
+                continue
+            if rule_part.lstrip().startswith("="):
+                continue
+            recipe_part = recipe_part.strip()
+            while recipe_part.startswith("[") and "]" in recipe_part:
+                recipe_part = recipe_part.split("]", 1)[1].strip()
+            if not recipe_part:
+                continue
+            recipe = recipe_part.split()[0].lstrip("@")
+            if recipe and not recipe.startswith("["):
+                recipes.add(recipe)
+    return recipes
+
+
 def missing_package_script_commands(root: Path, value: str | None) -> list[str]:
     if value is None:
         return []
@@ -463,6 +543,38 @@ def missing_package_script_commands(root: Path, value: str | None) -> list[str]:
     ]
 
 
+def missing_make_commands(root: Path, value: str | None) -> list[str]:
+    if value is None:
+        return []
+    commands = sorted(
+        {
+            normalize_command_target(match.group("target"))
+            for match in MAKE_COMMAND_RE.finditer(value)
+        }
+    )
+    if not commands:
+        return []
+
+    targets = root_make_targets(root)
+    return [f"make {target}" for target in commands if target not in targets]
+
+
+def missing_just_commands(root: Path, value: str | None) -> list[str]:
+    if value is None:
+        return []
+    commands = sorted(
+        {
+            normalize_command_target(match.group("recipe"))
+            for match in JUST_COMMAND_RE.finditer(value)
+        }
+    )
+    if not commands:
+        return []
+
+    recipes = root_just_recipes(root)
+    return [f"just {recipe}" for recipe in commands if recipe not in recipes]
+
+
 def says_no_failure_record(value: str | None) -> bool:
     if value is None:
         return False
@@ -626,6 +738,26 @@ def validate_adoption_report(root: Path, path: Path, text: str) -> list[Finding]
                         ),
                     )
                 )
+            for command in missing_make_commands(root, detection_value):
+                findings.append(
+                    Finding(
+                        path,
+                        (
+                            "failure-memory detection references missing "
+                            f"Makefile target: {command}"
+                        ),
+                    )
+                )
+            for command in missing_just_commands(root, detection_value):
+                findings.append(
+                    Finding(
+                        path,
+                        (
+                            "failure-memory detection references missing "
+                            f"justfile recipe: {command}"
+                        ),
+                    )
+                )
 
     return findings
 
@@ -646,7 +778,7 @@ def validate_effectiveness_report(path: Path, text: str) -> list[Finding]:
     return findings
 
 
-def validate_task_outcome(path: Path, text: str) -> list[Finding]:
+def validate_task_outcome(root: Path, path: Path, text: str) -> list[Finding]:
     report_include_value = yaml_field_value(text, "include_in_effectiveness_report")
     comparable_count_value = yaml_field_value(
         text, "include_in_comparable_product_task_count"
@@ -679,6 +811,22 @@ def validate_task_outcome(path: Path, text: str) -> list[Finding]:
             )
         )
 
+    verification_command = yaml_field_value(text, "verification_command")
+    for command in missing_make_commands(root, verification_command):
+        findings.append(
+            Finding(
+                path,
+                f"task outcome verification references missing Makefile target: {command}",
+            )
+        )
+    for command in missing_just_commands(root, verification_command):
+        findings.append(
+            Finding(
+                path,
+                f"task outcome verification references missing justfile recipe: {command}",
+            )
+        )
+
     truthy_include_fields = [
         field
         for field in TASK_OUTCOME_INCLUDE_FIELDS
@@ -790,7 +938,9 @@ def check_effectiveness_plan(root: Path, require_report: bool) -> int:
             findings.extend(validate_effectiveness_report(path, text))
 
     for path in iter_task_outcomes(root):
-        findings.extend(validate_task_outcome(path, path.read_text(encoding="utf-8")))
+        findings.extend(
+            validate_task_outcome(root, path, path.read_text(encoding="utf-8"))
+        )
 
     for finding in findings:
         print(f"{finding.path.relative_to(root)}: {finding.message}")
diff --git a/scripts/check_failure_memory.py b/scripts/check_failure_memory.py
index cb356b0..138c6a3 100644
--- a/scripts/check_failure_memory.py
+++ b/scripts/check_failure_memory.py
@@ -24,7 +24,11 @@
     re.compile(r"\b(?:tests?|specs?|fixtures?|scripts?)/[^\s,.;)]+"),
     re.compile(r"`?\.github/workflows/[^\s,.;)`]+`?"),
     re.compile(r"\b(?:npm|pnpm|yarn|bun)\s+run\s+[\w:./-]+"),
-    re.compile(r"\b(?:make|just)\s+[\w:./-]+"),
+    re.compile(
+        r"\bmake(?:\s+[\w.-]+=[^\s,;)`\]}]+)*\s+(?!-)[\w:./-]+"
+        r"(?=$|[\s,.;)`\]}])"
+    ),
+    re.compile(r"\bjust\s+(?!-)[\w:./-]+"),
     re.compile(r"\bpython3?\s+(?:-m\s+[\w.:-]+|scripts?/[^\s,.;)]+)"),
     re.compile(r"\bpytest\s+(?:-[\w-]+|tests?/[^\s,.;)]+|[\w/.-]+)"),
     re.compile(r"\b(?:vitest|jest|ruff|mypy|eslint)\s+[\w/.:@-]+"),
@@ -43,6 +47,13 @@
 PACKAGE_SCRIPT_COMMAND_RE = re.compile(
     r"\b(?P<manager>npm|pnpm|yarn|bun)\s+run\s+(?P<script>[\w:./-]+)"
 )
+MAKE_COMMAND_RE = re.compile(
+    r"\bmake(?:\s+[\w.-]+=[^\s,;)`\]}]+)*\s+(?!-)(?P<target>[\w:./-]+)"
+    r"(?=$|[\s,.;)`\]}])"
+)
+JUST_COMMAND_RE = re.compile(r"\bjust\s+(?!-)(?P<recipe>[\w:./-]+)")
+MAKEFILE_NAMES = ("GNUmakefile", "makefile", "Makefile")
+JUSTFILE_NAMES = ("justfile", "Justfile", ".justfile")
 
 REJECTED_PHRASES = (
     "no test has been added",
@@ -149,6 +160,10 @@ def normalize_package_script(value: str) -> str:
     return value.rstrip(".,;)]}")
 
 
+def normalize_command_target(value: str) -> str:
+    return value.rstrip(".,;)]}")
+
+
 def root_package_scripts(root: Path) -> set[str]:
     package_json = root / "package.json"
     if not package_json.exists():
@@ -163,6 +178,71 @@ def root_package_scripts(root: Path) -> set[str]:
     return {str(name) for name in package_scripts}
 
 
+def root_make_targets(root: Path) -> set[str]:
+    targets: set[str] = set()
+    path = next(
+        (root / name for name in MAKEFILE_NAMES if (root / name).exists()),
+        None,
+    )
+    if path is None:
+        return targets
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except (OSError, UnicodeDecodeError):
+        return targets
+    for raw_line in lines:
+        if not raw_line or raw_line[:1].isspace():
+            continue
+        line = raw_line.split("#", 1)[0].rstrip()
+        if ":" not in line:
+            continue
+        target_part, rule_part = line.split(":", 1)
+        if not target_part.strip() or "=" in target_part:
+            continue
+        if rule_part.lstrip().startswith("="):
+            continue
+        for target in target_part.split():
+            if target and "%" not in target and not target.startswith("."):
+                targets.add(target)
+    return targets
+
+
+def root_just_recipes(root: Path) -> set[str]:
+    recipes: set[str] = set()
+    for name in JUSTFILE_NAMES:
+        path = root / name
+        if not path.exists():
+            continue
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except (OSError, UnicodeDecodeError):
+            continue
+        for raw_line in lines:
+            if not raw_line or raw_line[:1].isspace():
+                continue
+            line = raw_line.split("#", 1)[0].rstrip()
+            alias_match = re.match(r"alias\s+(?P<name>[\w.-]+)\s*:=", line)
+            if alias_match is not None:
+                recipes.add(alias_match.group("name"))
+                continue
+            if ":" not in line:
+                continue
+            recipe_part, rule_part = line.split(":", 1)
+            if not recipe_part.strip():
+                continue
+            if rule_part.lstrip().startswith("="):
+                continue
+            recipe_part = recipe_part.strip()
+            while recipe_part.startswith("[") and "]" in recipe_part:
+                recipe_part = recipe_part.split("]", 1)[1].strip()
+            if not recipe_part:
+                continue
+            recipe = recipe_part.split()[0].lstrip("@")
+            if recipe and not recipe.startswith("["):
+                recipes.add(recipe)
+    return recipes
+
+
 def missing_package_script_commands(root: Path, section: str) -> list[str]:
     commands = sorted(
         {
@@ -181,6 +261,34 @@ def missing_package_script_commands(root: Path, section: str) -> list[str]:
     ]
 
 
+def missing_make_commands(root: Path, section: str) -> list[str]:
+    commands = sorted(
+        {
+            normalize_command_target(match.group("target"))
+            for match in MAKE_COMMAND_RE.finditer(section)
+        }
+    )
+    if not commands:
+        return []
+
+    targets = root_make_targets(root)
+    return [f"make {target}" for target in commands if target not in targets]
+
+
+def missing_just_commands(root: Path, section: str) -> list[str]:
+    commands = sorted(
+        {
+            normalize_command_target(match.group("recipe"))
+            for match in JUST_COMMAND_RE.finditer(section)
+        }
+    )
+    if not commands:
+        return []
+
+    recipes = root_just_recipes(root)
+    return [f"just {recipe}" for recipe in commands if recipe not in recipes]
+
+
 def validate_record(root: Path, path: Path) -> list[Finding]:
     text = path.read_text(encoding="utf-8")
     findings: list[Finding] = []
@@ -239,6 +347,20 @@ def validate_record(root: Path, path: Path) -> list[Finding]:
                 ),
             )
         )
+    for command in missing_make_commands(root, detection_section):
+        findings.append(
+            Finding(
+                path,
+                f"make command references missing Makefile target: {command}",
+            )
+        )
+    for command in missing_just_commands(root, detection_section):
+        findings.append(
+            Finding(
+                path,
+                f"just command references missing justfile recipe: {command}",
+            )
+        )
 
     return findings
 
diff --git a/templates/generic/scripts/check_effectiveness_plan.py b/templates/generic/scripts/check_effectiveness_plan.py
index 2ebed19..aa0f72c 100644
--- a/templates/generic/scripts/check_effectiveness_plan.py
+++ b/templates/generic/scripts/check_effectiveness_plan.py
@@ -97,7 +97,11 @@
     re.compile(r"\b(?:tests?|specs?|fixtures?|scripts?)/[^\s,.;)]+"),
     re.compile(r"`?\.github/workflows/[^\s,.;)`]+`?"),
     re.compile(r"\b(?:npm|pnpm|yarn|bun)\s+run\s+[\w:./-]+"),
-    re.compile(r"\b(?:make|just)\s+[\w:./-]+"),
+    re.compile(
+        r"\bmake(?:\s+[\w.-]+=[^\s,;)`\]}]+)*\s+(?!-)[\w:./-]+"
+        r"(?=$|[\s,.;)`\]}])"
+    ),
+    re.compile(r"\bjust\s+(?!-)[\w:./-]+"),
     re.compile(r"\bpython3?\s+(?:-m\s+[\w.:-]+|scripts?/[^\s,.;)]+)"),
     re.compile(r"\bpytest\s+(?:-[\w-]+|tests?/[^\s,.;)]+|[\w/.-]+)"),
     re.compile(r"\b(?:vitest|jest|ruff|mypy|eslint)\s+[\w/.:@-]+"),
@@ -116,6 +120,13 @@
 PACKAGE_SCRIPT_COMMAND_RE = re.compile(
     r"\b(?P<manager>npm|pnpm|yarn|bun)\s+run\s+(?P<script>[\w:./-]+)"
 )
+MAKE_COMMAND_RE = re.compile(
+    r"\bmake(?:\s+[\w.-]+=[^\s,;)`\]}]+)*\s+(?!-)(?P<target>[\w:./-]+)"
+    r"(?=$|[\s,.;)`\]}])"
+)
+JUST_COMMAND_RE = re.compile(r"\bjust\s+(?!-)(?P<recipe>[\w:./-]+)")
+MAKEFILE_NAMES = ("GNUmakefile", "makefile", "Makefile")
+JUSTFILE_NAMES = ("justfile", "Justfile", ".justfile")
 
 FAILURE_RECORD_RE = re.compile(
     r"`?(docs/failures/[^\s,;)`]+)`?",
@@ -429,6 +440,10 @@ def normalize_package_script(value: str) -> str:
     return value.rstrip(".,;)]}")
 
 
+def normalize_command_target(value: str) -> str:
+    return value.rstrip(".,;)]}")
+
+
 def root_package_scripts(root: Path) -> set[str]:
     package_json = root / "package.json"
     if not package_json.exists():
@@ -443,6 +458,71 @@ def root_package_scripts(root: Path) -> set[str]:
     return {str(name) for name in package_scripts}
 
 
+def root_make_targets(root: Path) -> set[str]:
+    targets: set[str] = set()
+    path = next(
+        (root / name for name in MAKEFILE_NAMES if (root / name).exists()),
+        None,
+    )
+    if path is None:
+        return targets
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except (OSError, UnicodeDecodeError):
+        return targets
+    for raw_line in lines:
+        if not raw_line or raw_line[:1].isspace():
+            continue
+        line = raw_line.split("#", 1)[0].rstrip()
+        if ":" not in line:
+            continue
+        target_part, rule_part = line.split(":", 1)
+        if not target_part.strip() or "=" in target_part:
+            continue
+        if rule_part.lstrip().startswith("="):
+            continue
+        for target in target_part.split():
+            if target and "%" not in target and not target.startswith("."):
+                targets.add(target)
+    return targets
+
+
+def root_just_recipes(root: Path) -> set[str]:
+    recipes: set[str] = set()
+    for name in JUSTFILE_NAMES:
+        path = root / name
+        if not path.exists():
+            continue
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except (OSError, UnicodeDecodeError):
+            continue
+        for raw_line in lines:
+            if not raw_line or raw_line[:1].isspace():
+                continue
+            line = raw_line.split("#", 1)[0].rstrip()
+            alias_match = re.match(r"alias\s+(?P<name>[\w.-]+)\s*:=", line)
+            if alias_match is not None:
+                recipes.add(alias_match.group("name"))
+                continue
+            if ":" not in line:
+                continue
+            recipe_part, rule_part = line.split(":", 1)
+            if not recipe_part.strip():
+                continue
+            if rule_part.lstrip().startswith("="):
+                continue
+            recipe_part = recipe_part.strip()
+            while recipe_part.startswith("[") and "]" in recipe_part:
+                recipe_part = recipe_part.split("]", 1)[1].strip()
+            if not recipe_part:
+                continue
+            recipe = recipe_part.split()[0].lstrip("@")
+            if recipe and not recipe.startswith("["):
+                recipes.add(recipe)
+    return recipes
+
+
 def missing_package_script_commands(root: Path, value: str | None) -> list[str]:
     if value is None:
         return []
@@ -463,6 +543,38 @@ def missing_package_script_commands(root: Path, value: str | None) -> list[str]:
     ]
 
 
+def missing_make_commands(root: Path, value: str | None) -> list[str]:
+    if value is None:
+        return []
+    commands = sorted(
+        {
+            normalize_command_target(match.group("target"))
+            for match in MAKE_COMMAND_RE.finditer(value)
+        }
+    )
+    if not commands:
+        return []
+
+    targets = root_make_targets(root)
+    return [f"make {target}" for target in commands if target not in targets]
+
+
+def missing_just_commands(root: Path, value: str | None) -> list[str]:
+    if value is None:
+        return []
+    commands = sorted(
+        {
+            normalize_command_target(match.group("recipe"))
+            for match in JUST_COMMAND_RE.finditer(value)
+        }
+    )
+    if not commands:
+        return []
+
+    recipes = root_just_recipes(root)
+    return [f"just {recipe}" for recipe in commands if recipe not in recipes]
+
+
 def says_no_failure_record(value: str | None) -> bool:
     if value is None:
         return False
@@ -626,6 +738,26 @@ def validate_adoption_report(root: Path, path: Path, text: str) -> list[Finding]
                         ),
                     )
                 )
+            for command in missing_make_commands(root, detection_value):
+                findings.append(
+                    Finding(
+                        path,
+                        (
+                            "failure-memory detection references missing "
+                            f"Makefile target: {command}"
+                        ),
+                    )
+                )
+            for command in missing_just_commands(root, detection_value):
+                findings.append(
+                    Finding(
+                        path,
+                        (
+                            "failure-memory detection references missing "
+                            f"justfile recipe: {command}"
+                        ),
+                    )
+                )
 
     return findings
 
@@ -646,7 +778,7 @@ def validate_effectiveness_report(path: Path, text: str) -> list[Finding]:
     return findings
 
 
-def validate_task_outcome(path: Path, text: str) -> list[Finding]:
+def validate_task_outcome(root: Path, path: Path, text: str) -> list[Finding]:
     report_include_value = yaml_field_value(text, "include_in_effectiveness_report")
     comparable_count_value = yaml_field_value(
         text, "include_in_comparable_product_task_count"
@@ -679,6 +811,22 @@ def validate_task_outcome(path: Path, text: str) -> list[Finding]:
             )
         )
 
+    verification_command = yaml_field_value(text, "verification_command")
+    for command in missing_make_commands(root, verification_command):
+        findings.append(
+            Finding(
+                path,
+                f"task outcome verification references missing Makefile target: {command}",
+            )
+        )
+    for command in missing_just_commands(root, verification_command):
+        findings.append(
+            Finding(
+                path,
+                f"task outcome verification references missing justfile recipe: {command}",
+            )
+        )
+
     truthy_include_fields = [
         field
         for field in TASK_OUTCOME_INCLUDE_FIELDS
@@ -790,7 +938,9 @@ def check_effectiveness_plan(root: Path, require_report: bool) -> int:
             findings.extend(validate_effectiveness_report(path, text))
 
     for path in iter_task_outcomes(root):
-        findings.extend(validate_task_outcome(path, path.read_text(encoding="utf-8")))
+        findings.extend(
+            validate_task_outcome(root, path, path.read_text(encoding="utf-8"))
+        )
 
     for finding in findings:
         print(f"{finding.path.relative_to(root)}: {finding.message}")
diff --git a/templates/generic/scripts/check_failure_memory.py b/templates/generic/scripts/check_failure_memory.py
index cb356b0..138c6a3 100644
--- a/templates/generic/scripts/check_failure_memory.py
+++ b/templates/generic/scripts/check_failure_memory.py
@@ -24,7 +24,11 @@
     re.compile(r"\b(?:tests?|specs?|fixtures?|scripts?)/[^\s,.;)]+"),
     re.compile(r"`?\.github/workflows/[^\s,.;)`]+`?"),
     re.compile(r"\b(?:npm|pnpm|yarn|bun)\s+run\s+[\w:./-]+"),
-    re.compile(r"\b(?:make|just)\s+[\w:./-]+"),
+    re.compile(
+        r"\bmake(?:\s+[\w.-]+=[^\s,;)`\]}]+)*\s+(?!-)[\w:./-]+"
+        r"(?=$|[\s,.;)`\]}])"
+    ),
+    re.compile(r"\bjust\s+(?!-)[\w:./-]+"),
     re.compile(r"\bpython3?\s+(?:-m\s+[\w.:-]+|scripts?/[^\s,.;)]+)"),
     re.compile(r"\bpytest\s+(?:-[\w-]+|tests?/[^\s,.;)]+|[\w/.-]+)"),
     re.compile(r"\b(?:vitest|jest|ruff|mypy|eslint)\s+[\w/.:@-]+"),
@@ -43,6 +47,13 @@
 PACKAGE_SCRIPT_COMMAND_RE = re.compile(
     r"\b(?P<manager>npm|pnpm|yarn|bun)\s+run\s+(?P<script>[\w:./-]+)"
 )
+MAKE_COMMAND_RE = re.compile(
+    r"\bmake(?:\s+[\w.-]+=[^\s,;)`\]}]+)*\s+(?!-)(?P<target>[\w:./-]+)"
+    r"(?=$|[\s,.;)`\]}])"
+)
+JUST_COMMAND_RE = re.compile(r"\bjust\s+(?!-)(?P<recipe>[\w:./-]+)")
+MAKEFILE_NAMES = ("GNUmakefile", "makefile", "Makefile")
+JUSTFILE_NAMES = ("justfile", "Justfile", ".justfile")
 
 REJECTED_PHRASES = (
     "no test has been added",
@@ -149,6 +160,10 @@ def normalize_package_script(value: str) -> str:
     return value.rstrip(".,;)]}")
 
 
+def normalize_command_target(value: str) -> str:
+    return value.rstrip(".,;)]}")
+
+
 def root_package_scripts(root: Path) -> set[str]:
     package_json = root / "package.json"
     if not package_json.exists():
@@ -163,6 +178,71 @@ def root_package_scripts(root: Path) -> set[str]:
     return {str(name) for name in package_scripts}
 
 
+def root_make_targets(root: Path) -> set[str]:
+    targets: set[str] = set()
+    path = next(
+        (root / name for name in MAKEFILE_NAMES if (root / name).exists()),
+        None,
+    )
+    if path is None:
+        return targets
+    try:
+        lines = path.read_text(encoding="utf-8").splitlines()
+    except (OSError, UnicodeDecodeError):
+        return targets
+    for raw_line in lines:
+        if not raw_line or raw_line[:1].isspace():
+            continue
+        line = raw_line.split("#", 1)[0].rstrip()
+        if ":" not in line:
+            continue
+        target_part, rule_part = line.split(":", 1)
+        if not target_part.strip() or "=" in target_part:
+            continue
+        if rule_part.lstrip().startswith("="):
+            continue
+        for target in target_part.split():
+            if target and "%" not in target and not target.startswith("."):
+                targets.add(target)
+    return targets
+
+
+def root_just_recipes(root: Path) -> set[str]:
+    recipes: set[str] = set()
+    for name in JUSTFILE_NAMES:
+        path = root / name
+        if not path.exists():
+            continue
+        try:
+            lines = path.read_text(encoding="utf-8").splitlines()
+        except (OSError, UnicodeDecodeError):
+            continue
+        for raw_line in lines:
+            if not raw_line or raw_line[:1].isspace():
+                continue
+            line = raw_line.split("#", 1)[0].rstrip()
+            alias_match = re.match(r"alias\s+(?P<name>[\w.-]+)\s*:=", line)
+            if alias_match is not None:
+                recipes.add(alias_match.group("name"))
+                continue
+            if ":" not in line:
+                continue
+            recipe_part, rule_part = line.split(":", 1)
+            if not recipe_part.strip():
+                continue
+            if rule_part.lstrip().startswith("="):
+                continue
+            recipe_part = recipe_part.strip()
+            while recipe_part.startswith("[") and "]" in recipe_part:
+                recipe_part = recipe_part.split("]", 1)[1].strip()
+            if not recipe_part:
+                continue
+            recipe = recipe_part.split()[0].lstrip("@")
+            if recipe and not recipe.startswith("["):
+                recipes.add(recipe)
+    return recipes
+
+
 def missing_package_script_commands(root: Path, section: str) -> list[str]:
     commands = sorted(
         {
@@ -181,6 +261,34 @@ def missing_package_script_commands(root: Path, section: str) -> list[str]:
     ]
 
 
+def missing_make_commands(root: Path, section: str) -> list[str]:
+    commands = sorted(
+        {
+            normalize_command_target(match.group("target"))
+            for match in MAKE_COMMAND_RE.finditer(section)
+        }
+    )
+    if not commands:
+        return []
+
+    targets = root_make_targets(root)
+    return [f"make {target}" for target in commands if target not in targets]
+
+
+def missing_just_commands(root: Path, section: str) -> list[str]:
+    commands = sorted(
+        {
+            normalize_command_target(match.group("recipe"))
+            for match in JUST_COMMAND_RE.finditer(section)
+        }
+    )
+    if not commands:
+        return []
+
+    recipes = root_just_recipes(root)
+    return [f"just {recipe}" for recipe in commands if recipe not in recipes]
+
+
 def validate_record(root: Path, path: Path) -> list[Finding]:
     text = path.read_text(encoding="utf-8")
     findings: list[Finding] = []
@@ -239,6 +347,20 @@ def validate_record(root: Path, path: Path) -> list[Finding]:
                 ),
             )
         )
+    for command in missing_make_commands(root, detection_section):
+        findings.append(
+            Finding(
+                path,
+                f"make command references missing Makefile target: {command}",
+            )
+        )
+    for command in missing_just_commands(root, detection_section):
+        findings.append(
+            Finding(
+                path,
+                f"just command references missing justfile recipe: {command}",
+            )
+        )
 
     return findings
 
diff --git a/tests/test_check_effectiveness_plan.py b/tests/test_check_effectiveness_plan.py
index f668597..94a3f5d 100644
--- a/tests/test_check_effectiveness_plan.py
+++ b/tests/test_check_effectiveness_plan.py
@@ -165,6 +165,12 @@ def write_package_json(self, root: Path, scripts: dict[str, str]) -> None:
             encoding="utf-8",
         )
 
+    def write_makefile(self, root: Path, text: str) -> None:
+        (root / "Makefile").write_text(text, encoding="utf-8")
+
+    def write_justfile(self, root: Path, text: str) -> None:
+        (root / "justfile").write_text(text, encoding="utf-8")
+
     def test_no_report_passes_unless_report_is_required(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)
@@ -631,6 +637,195 @@ def test_recorded_failure_with_missing_package_script_fails(self) -> None:
             )
             self.assertEqual(1, result.returncode)
 
+    def test_recorded_failure_with_make_or_just_command_detection_passes(self) -> None:
+        examples = (
+            ("make check.", "Makefile", "check:\n\tpython3 -m unittest\n"),
+            ("just verify.", "justfile", "@verify:\n    python3 -m unittest\n"),
+            (
+                "just ci.",
+                "justfile",
+                "alias ci := verify\nverify:\n    python3 -m unittest\n",
+            ),
+            (
+                "just deploy.",
+                "justfile",
+                "deploy env='prod':\n    python3 -m unittest\n",
+            ),
+        )
+        for command, command_file, command_file_text in examples:
+            with self.subTest(command=command):
+                with tempfile.TemporaryDirectory() as tmp:
+                    root = Path(tmp)
+                    self.write_failure_record(root)
+                    (root / command_file).write_text(
+                        command_file_text,
+                        encoding="utf-8",
+                    )
+                    report = COMPLETE_ADOPTION_REPORT.replace(
+                        "- Recorded: none; no recurring failure was fixed.",
+                        "- Recorded: `docs/failures/0001-provider-casing.md`.",
+                    ).replace(
+                        "- Detection or prevention check: not applicable because no failure record was\n"
+                        "  added.",
+                        f"- Detection or prevention check: `{command}`",
+                    ).replace(
+                        "- Skipped: no user-visible runtime failure, high-risk bug path, failed check,\n"
+                        "  CI failure, repeated agent mistake, or cross-environment mismatch was fixed.",
+                        "- Skipped: none; failure memory was recorded.",
+                    )
+                    (root / "adoption-report.md").write_text(report, encoding="utf-8")
+
+                    result = self.run_checker(root)
+
+                    self.assertEqual("", result.stdout)
+                    self.assertEqual(0, result.returncode)
+
+    def test_recorded_failure_with_missing_make_target_fails(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.write_failure_record(root)
+            self.write_makefile(root, "other:\n\tpython3 -m unittest\n")
+            report = COMPLETE_ADOPTION_REPORT.replace(
+                "- Recorded: none; no recurring failure was fixed.",
+                "- Recorded: `docs/failures/0001-provider-casing.md`.",
+            ).replace(
+                "- Detection or prevention check: not applicable because no failure record was\n"
+                "  added.",
+                "- Detection or prevention check: `make check`.",
+            ).replace(
+                "- Skipped: no user-visible runtime failure, high-risk bug path, failed check,\n"
+                "  CI failure, repeated agent mistake, or cross-environment mismatch was fixed.",
+                "- Skipped: none; failure memory was recorded.",
+            )
+            (root / "adoption-report.md").write_text(report, encoding="utf-8")
+
+            result = self.run_checker(root)
+
+            self.assertIn(
+                "failure-memory detection references missing Makefile target: make check",
+                result.stdout,
+            )
+            self.assertEqual(1, result.returncode)
+
+    def test_recorded_failure_make_command_allows_leading_variable_assignments(
+        self,
+    ) -> None:
+        examples = (
+            "make ENV=ci check",
+            "make PYTHON=python3.11 check",
+        )
+        for command in examples:
+            with self.subTest(command=command):
+                with tempfile.TemporaryDirectory() as tmp:
+                    root = Path(tmp)
+                    self.write_failure_record(root)
+                    self.write_makefile(root, "check:\n\tpython3 -m unittest\n")
+                    report = COMPLETE_ADOPTION_REPORT.replace(
+                        "- Recorded: none; no recurring failure was fixed.",
+                        "- Recorded: `docs/failures/0001-provider-casing.md`.",
+                    ).replace(
+                        "- Detection or prevention check: not applicable because no failure record was\n"
+                        "  added.",
+                        f"- Detection or prevention check: `{command}`.",
+                    ).replace(
+                        "- Skipped: no user-visible runtime failure, high-risk bug path, failed check,\n"
+                        "  CI failure, repeated agent mistake, or cross-environment mismatch was fixed.",
+                        "- Skipped: none; failure memory was recorded.",
+                    )
+                    (root / "adoption-report.md").write_text(report, encoding="utf-8")
+
+                    result = self.run_checker(root)
+
+                    self.assertEqual("", result.stdout)
+                    self.assertEqual(0, result.returncode)
+
+    def test_recorded_failure_make_variable_assignment_without_target_is_not_concrete(
+        self,
+    ) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.write_failure_record(root)
+            self.write_makefile(root, "check:\n\tpython3 -m unittest\n")
+            report = COMPLETE_ADOPTION_REPORT.replace(
+                "- Recorded: none; no recurring failure was fixed.",
+                "- Recorded: `docs/failures/0001-provider-casing.md`.",
+            ).replace(
+                "- Detection or prevention check: not applicable because no failure record was\n"
+                "  added.",
+                "- Detection or prevention check: `make ENV=ci`.",
+            ).replace(
+                "- Skipped: no user-visible runtime failure, high-risk bug path, failed check,\n"
+                "  CI failure, repeated agent mistake, or cross-environment mismatch was fixed.",
+                "- Skipped: none; failure memory was recorded.",
+            )
+            (root / "adoption-report.md").write_text(report, encoding="utf-8")
+
+            result = self.run_checker(root)
+
+            self.assertIn(
+                "incomplete failure-memory detection link",
+                result.stdout,
+            )
+            self.assertEqual(1, result.returncode)
+
+    def test_recorded_failure_make_command_uses_gnu_makefile_precedence(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.write_failure_record(root)
+            (root / "GNUmakefile").write_text(
+                "other:\n\tpython3 -m unittest\n",
+                encoding="utf-8",
+            )
+            self.write_makefile(root, "check:\n\tpython3 -m unittest\n")
+            report = COMPLETE_ADOPTION_REPORT.replace(
+                "- Recorded: none; no recurring failure was fixed.",
+                "- Recorded: `docs/failures/0001-provider-casing.md`.",
+            ).replace(
+                "- Detection or prevention check: not applicable because no failure record was\n"
+                "  added.",
+                "- Detection or prevention check: `make check`.",
+            ).replace(
+                "- Skipped: no user-visible runtime failure, high-risk bug path, failed check,\n"
+                "  CI failure, repeated agent mistake, or cross-environment mismatch was fixed.",
+                "- Skipped: none; failure memory was recorded.",
+            )
+            (root / "adoption-report.md").write_text(report, encoding="utf-8")
+
+            result = self.run_checker(root)
+
+            self.assertIn(
+                "failure-memory detection references missing Makefile target: make check",
+                result.stdout,
+            )
+            self.assertEqual(1, result.returncode)
+
+    def test_recorded_failure_with_missing_just_recipe_fails(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.write_failure_record(root)
+            self.write_justfile(root, "other:\n    python3 -m unittest\n")
+            report = COMPLETE_ADOPTION_REPORT.replace(
+                "- Recorded: none; no recurring failure was fixed.",
+                "- Recorded: `docs/failures/0001-provider-casing.md`.",
+            ).replace(
+                "- Detection or prevention check: not applicable because no failure record was\n"
+                "  added.",
+                "- Detection or prevention check: `just verify`.",
+            ).replace(
+                "- Skipped: no user-visible runtime failure, high-risk bug path, failed check,\n"
+                "  CI failure, repeated agent mistake, or cross-environment mismatch was fixed.",
+                "- Skipped: none; failure memory was recorded.",
+            )
+            (root / "adoption-report.md").write_text(report, encoding="utf-8")
+
+            result = self.run_checker(root)
+
+            self.assertIn(
+                "failure-memory detection references missing justfile recipe: just verify",
+                result.stdout,
+            )
+            self.assertEqual(1, result.returncode)
+
     def test_recorded_failure_requires_root_package_script(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)
@@ -1075,6 +1270,93 @@ def test_included_task_outcome_requires_first_pass_result(self) -> None:
             )
             self.assertEqual(1, result.returncode)
 
+    def test_included_task_outcome_make_or_just_verification_passes_when_defined(
+        self,
+    ) -> None:
+        examples = (
+            ("make check.", "Makefile", "check:\n\tpython3 -m unittest\n"),
+            ("just verify.", "justfile", "@verify:\n    python3 -m unittest\n"),
+            (
+                "just ci.",
+                "justfile",
+                "alias ci := verify\nverify:\n    python3 -m unittest\n",
+            ),
+            (
+                "just deploy.",
+                "justfile",
+                "deploy env='prod':\n    python3 -m unittest\n",
+            ),
+        )
+        for command, command_file, command_file_text in examples:
+            with self.subTest(command=command):
+                with tempfile.TemporaryDirectory() as tmp:
+                    root = Path(tmp)
+                    (root / command_file).write_text(
+                        command_file_text,
+                        encoding="utf-8",
+                    )
+                    self.write_task_outcome(
+                        root,
+                        "docs/effectiveness/task-outcomes/001-route.yaml",
+                        verification_command=command,
+                    )
+
+                    result = self.run_checker(root)
+
+                    self.assertEqual("", result.stdout)
+                    self.assertEqual(0, result.returncode)
+
+    def test_included_task_outcome_make_or_just_verification_must_exist(self) -> None:
+        examples = (
+            (
+                "make check",
+                "task outcome verification references missing Makefile target: make check",
+            ),
+            (
+                "make PYTHON=python3.11 missing",
+                "task outcome verification references missing Makefile target: make missing",
+            ),
+            (
+                "just verify",
+                "task outcome verification references missing justfile recipe: just verify",
+            ),
+        )
+        for command, expected_message in examples:
+            with self.subTest(command=command):
+                with tempfile.TemporaryDirectory() as tmp:
+                    root = Path(tmp)
+                    self.write_task_outcome(
+                        root,
+                        "docs/effectiveness/task-outcomes/001-route.yaml",
+                        verification_command=command,
+                    )
+
+                    result = self.run_checker(root)
+
+                    self.assertIn(expected_message, result.stdout)
+                    self.assertEqual(1, result.returncode)
+
+    def test_false_inclusion_task_outcome_still_validates_make_verification(
+        self,
+    ) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.write_task_outcome(
+                root,
+                "docs/effectiveness/task-outcomes/001-route.yaml",
+                include_in_report="false",
+                include_in_count="false",
+                verification_command="make check",
+            )
+
+            result = self.run_checker(root)
+
+            self.assertIn(
+                "task outcome verification references missing Makefile target: make check",
+                result.stdout,
+            )
+            self.assertEqual(1, result.returncode)
+
     def test_task_outcome_template_with_false_inclusion_passes(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)
diff --git a/tests/test_check_failure_memory.py b/tests/test_check_failure_memory.py
index c9025bf..7796cda 100644
--- a/tests/test_check_failure_memory.py
+++ b/tests/test_check_failure_memory.py
@@ -83,6 +83,12 @@ def write_package_json(self, root: Path, scripts: dict[str, str]) -> None:
             encoding="utf-8",
         )
 
+    def write_makefile(self, root: Path, text: str) -> None:
+        (root / "Makefile").write_text(text, encoding="utf-8")
+
+    def write_justfile(self, root: Path, text: str) -> None:
+        (root / "justfile").write_text(text, encoding="utf-8")
+
     def test_no_failure_records_passes(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             result = self.run_checker(Path(tmp))
@@ -259,6 +265,10 @@ def test_concrete_commands_pass(self) -> None:
                             root,
                             {"test:planner": "node --test planner.test.mjs"},
                         )
+                    if "make check" in example:
+                        self.write_makefile(root, "check:\n\tpython3 -m unittest\n")
+                    if "just verify" in example:
+                        self.write_justfile(root, "verify:\n    python3 -m unittest\n")
                     self.write_record(
                         root,
                         VALID_RECORD.replace(
@@ -273,6 +283,42 @@ def test_concrete_commands_pass(self) -> None:
                     self.assertEqual("", result.stdout)
                     self.assertEqual(0, result.returncode)
 
+    def test_make_and_just_commands_allow_terminal_punctuation(self) -> None:
+        examples = (
+            ("make check.", "Makefile", "check:\n\tpython3 -m unittest\n"),
+            ("just verify.", "justfile", "@verify:\n    python3 -m unittest\n"),
+            (
+                "just ci.",
+                "justfile",
+                "alias ci := verify\nverify:\n    python3 -m unittest\n",
+            ),
+            (
+                "just deploy.",
+                "justfile",
+                "deploy env='prod':\n    python3 -m unittest\n",
+            ),
+        )
+        for command, command_file, command_file_text in examples:
+            with self.subTest(command=command):
+                with tempfile.TemporaryDirectory() as tmp:
+                    root = Path(tmp)
+                    (root / command_file).write_text(
+                        command_file_text,
+                        encoding="utf-8",
+                    )
+                    self.write_record(
+                        root,
+                        VALID_RECORD.replace(
+                            "`tests/test_example.py` fails if the bug path returns.",
+                            command,
+                        ),
+                    )
+
+                    result = self.run_checker(root)
+
+                    self.assertEqual("", result.stdout)
+                    self.assertEqual(0, result.returncode)
+
     def test_package_manager_run_script_allows_terminal_punctuation(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)
@@ -368,6 +414,110 @@ def test_package_manager_run_script_requires_root_package_script(self) -> None:
             )
             self.assertEqual(1, result.returncode)
 
+    def test_make_command_target_must_exist(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.write_makefile(root, "other:\n\tpython3 -m unittest\n")
+            self.write_record(
+                root,
+                VALID_RECORD.replace(
+                    "`tests/test_example.py` fails if the bug path returns.",
+                    "`make check` runs the regression suite.",
+                ),
+            )
+
+            result = self.run_checker(root)
+
+            self.assertIn(
+                "make command references missing Makefile target: make check",
+                result.stdout,
+            )
+            self.assertEqual(1, result.returncode)
+
+    def test_make_command_allows_leading_variable_assignments(self) -> None:
+        examples = (
+            "make ENV=ci check",
+            "make PYTHON=python3.11 check",
+        )
+        for command in examples:
+            with self.subTest(command=command):
+                with tempfile.TemporaryDirectory() as tmp:
+                    root = Path(tmp)
+                    self.write_makefile(root, "check:\n\tpython3 -m unittest\n")
+                    self.write_record(
+                        root,
+                        VALID_RECORD.replace(
+                            "`tests/test_example.py` fails if the bug path returns.",
+                            f"`{command}` runs the regression suite.",
+                        ),
+                    )
+
+                    result = self.run_checker(root)
+
+                    self.assertEqual("", result.stdout)
+                    self.assertEqual(0, result.returncode)
+
+    def test_make_variable_assignment_without_target_is_not_concrete(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.write_makefile(root, "check:\n\tpython3 -m unittest\n")
+            self.write_record(
+                root,
+                VALID_RECORD.replace(
+                    "`tests/test_example.py` fails if the bug path returns.",
+                    "`make ENV=ci` does not name a check target.",
+                ),
+            )
+
+            result = self.run_checker(root)
+
+            self.assertIn("detection/prevention section must name", result.stdout)
+            self.assertEqual(1, result.returncode)
+
+    def test_make_command_uses_gnu_makefile_precedence(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / "GNUmakefile").write_text(
+                "other:\n\tpython3 -m unittest\n",
+                encoding="utf-8",
+            )
+            self.write_makefile(root, "check:\n\tpython3 -m unittest\n")
+            self.write_record(
+                root,
+                VALID_RECORD.replace(
+                    "`tests/test_example.py` fails if the bug path returns.",
+                    "`make check` runs the regression suite.",
+                ),
+            )
+
+            result = self.run_checker(root)
+
+            self.assertIn(
+                "make command references missing Makefile target: make check",
+                result.stdout,
+            )
+            self.assertEqual(1, result.returncode)
+
+    def test_just_command_recipe_must_exist(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            self.write_justfile(root, "other:\n    python3 -m unittest\n")
+            self.write_record(
+                root,
+                VALID_RECORD.replace(
+                    "`tests/test_example.py` fails if the bug path returns.",
+                    "`just verify` runs the harness gate.",
+                ),
+            )
+
+            result = self.run_checker(root)
+
+            self.assertIn(
+                "just command references missing justfile recipe: just verify",
+                result.stdout,
+            )
+            self.assertEqual(1, result.returncode)
+
     def test_valid_existing_path_may_include_planned_word(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)