taskledger 0.6.7__tar.gz → 0.6.8__tar.gz

{taskledger-0.6.7 → taskledger-0.6.8}/.ledger/releaseledger/data/ledgers/main/events/events.jsonl

@@ -50,3 +50,8 @@
 {"data":{"updated_rows":1},"event":"audit.updated","event_id":"event-0050","record_revisions":{"commit_audit_sheet":2},"release_version":"v0.6.7","schema_version":2}
 {"data":{"entry_ids":["entry-0001"],"synced_audit_rows":1},"event":"entry.batch_added","event_id":"event-0051","record_revisions":{"commit_audit_sheet":3,"entry:v0.6.7/entry-0001":1,"release:v0.6.7":3},"release_version":"v0.6.7","schema_version":2}
 {"data":{"released_at":"2026-09-09"},"event":"release.finalized","event_id":"event-0052","record_revisions":{"release:v0.6.7":4},"release_version":"v0.6.7","schema_version":2}
+{"data":{"status":"planned"},"event":"release.created","event_id":"event-0053","record_revisions":{"release:v0.6.8":1},"release_version":"v0.6.8","schema_version":2}
+{"data":{"fields":["git_base_ref","git_base_sha","git_commit_count","git_head_ref","git_head_sha","git_range"]},"event":"release.updated","event_id":"event-0054","record_revisions":{"release:v0.6.8":2},"release_version":"v0.6.8","schema_version":2}
+{"data":{"row_count":1},"event":"audit.created","event_id":"event-0055","record_revisions":{"commit_audit_sheet":1},"release_version":"v0.6.8","schema_version":2}
+{"data":{"updated_rows":1},"event":"audit.updated","event_id":"event-0056","record_revisions":{"commit_audit_sheet":2},"release_version":"v0.6.8","schema_version":2}
+{"data":{"kind":"added","status":"accepted"},"entry_id":"entry-0001","event":"entry.added","event_id":"event-0057","record_revisions":{"entry:v0.6.8/entry-0001":1,"release:v0.6.8":3},"release_version":"v0.6.8","schema_version":2}

taskledger-0.6.8/.ledger/releaseledger/data/ledgers/main/releases/v0.6.8/audit/commit-audit.yaml

@@ -0,0 +1,79 @@
+schema_version: 1
+object_type: commit_audit_sheet
+versioning:
+  schema_version: 1
+  revision: 2
+release_version: v0.6.8
+git_base_ref: v0.6.7
+git_base_sha: fa5b2b7720d3f05530e32e8389b7286e6fb186b1
+git_head_ref: HEAD
+git_head_sha: b5677429bc9b8209d918456cfb6a30fd11ce4970
+git_range: fa5b2b7720d3f05530e32e8389b7286e6fb186b1..b5677429bc9b8209d918456cfb6a30fd11ce4970
+commit_count: 1
+rows:
+  - sha: b5677429bc9b8209d918456cfb6a30fd11ce4970
+    source_ref: git:b5677429bc9b8209d918456cfb6a30fd11ce4970
+    short_sha: b567742
+    changed_paths:
+      - docs/command_contract.md
+      - docs/full_task_cycle.md
+      - skills/taskledger/SKILL.md
+      - taskledger/cli_validate.py
+      - taskledger/domain/check.py
+      - taskledger/domain/sidecars.py
+      - taskledger/services/check_reuse.py
+      - taskledger/services/check_tracking.py
+      - taskledger/services/doctor_checks/task_checks.py
+      - taskledger/services/handoff.py
+      - taskledger/services/implementation_flow.py
+      - taskledger/services/tasks.py
+      - taskledger/services/validation_flow.py
+      - taskledger/services/workflow_guidance.py
+      - tests/test_actor_resolution.py
+      - tests/test_check_reuse.py
+      - tests/test_check_reuse_context.py
+      - tests/test_doctor.py
+      - tests/test_implementation_checks.py
+      - tests/test_models_v1_schema.py
+    stats:
+      files_changed: 0
+      insertions: 841
+      deletions: 20
+    inspected: true
+    inspected_paths:
+      - docs/command_contract.md
+      - docs/full_task_cycle.md
+      - skills/taskledger/SKILL.md
+      - taskledger/cli_validate.py
+      - taskledger/domain/check.py
+      - taskledger/domain/sidecars.py
+      - taskledger/services/check_reuse.py
+      - taskledger/services/check_tracking.py
+      - taskledger/services/doctor_checks/task_checks.py
+      - taskledger/services/handoff.py
+      - taskledger/services/implementation_flow.py
+      - taskledger/services/tasks.py
+      - taskledger/services/validation_flow.py
+      - taskledger/services/workflow_guidance.py
+      - tests/test_actor_resolution.py
+      - tests/test_check_reuse.py
+      - tests/test_check_reuse_context.py
+      - tests/test_doctor.py
+      - tests/test_implementation_checks.py
+      - tests/test_models_v1_schema.py
+    observed_behavior:
+      Passing implementation command checks now record workspace snapshot
+      provenance, and validators can explicitly reuse those checks only when the implementation
+      and current workspace snapshots match exactly. Validation records the reused check
+      reference, while handoff context identifies reusable, stale, and unknown provenance
+      checks.
+    public_impact: public
+    decision: accepted
+    stale: false
+    evidence_subject:
+      "feat: improved implementation check handling to reduce amount
+      of tests needed for verification"
+    target_entry_key: implementation-check-evidence-reuse
+    notes:
+      Reviewed the implementation, validation, handoff, CLI, documentation, and
+      focused regression tests in this commit.

taskledger-0.6.8/.ledger/releaseledger/data/ledgers/main/releases/v0.6.8/entries/entry-0001.md

@@ -0,0 +1,31 @@
+---
+schema_version: 2
+object_type: release_entry
+versioning:
+  schema_version: 1
+  revision: 1
+entry_id: entry-0001
+release_version: v0.6.8
+kind: added
+summary:
+  Added explicit reuse of passing implementation checks as validation evidence
+  when final and current workspace snapshots match
+status: accepted
+audience: null
+scopes: []
+source_refs:
+  - git:b5677429bc9b8209d918456cfb6a30fd11ce4970
+paths:
+  - taskledger/cli_validate.py
+  - taskledger/services/check_reuse.py
+  - taskledger/services/validation_flow.py
+  - taskledger/services/handoff.py
+  - docs/command_contract.md
+issues: []
+prs: []
+sources: []
+contributors: []
+breaking: false
+internal: false
+order: 1
+---

taskledger-0.6.8/.ledger/releaseledger/data/ledgers/main/releases/v0.6.8/release.md

@@ -0,0 +1,27 @@
+---
+schema_version: 2
+object_type: release
+versioning:
+  schema_version: 1
+  revision: 3
+version: v0.6.8
+status: planned
+history_state: curated
+title: Release v0.6.8
+released_at: null
+previous_version: v0.6.7
+cancel_reason: null
+superseded_by: null
+changelog_file: null
+boundary_ref: null
+source_refs: []
+source_count: null
+entry_count: 1
+artifact_count: 0
+git_base_ref: v0.6.7
+git_base_sha: fa5b2b7720d3f05530e32e8389b7286e6fb186b1
+git_head_ref: HEAD
+git_head_sha: b5677429bc9b8209d918456cfb6a30fd11ce4970
+git_range: fa5b2b7720d3f05530e32e8389b7286e6fb186b1..b5677429bc9b8209d918456cfb6a30fd11ce4970
+git_commit_count: 1
+---

{taskledger-0.6.7/taskledger.egg-info → taskledger-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskledger
-Version: 0.6.7
+Version: 0.6.8
 Summary: Durable project-state storage and CLI for coding workflows
 Author: Taskledger Contributors
 Maintainer: Holger Nahrstaedt

{taskledger-0.6.7 → taskledger-0.6.8}/docs/changelog.md

@@ -2,6 +2,14 @@
 
 > **Generated by releaseledger.** Manual edits may be overwritten. Update releaseledger entries and rebuild this file instead.
 
+## [v0.6.8] - Unreleased
+
+### Added
+
+- Added explicit reuse of passing implementation checks as validation evidence when final and current workspace snapshots match
+
+<!-- generated by releaseledger -->
+
 ## [v0.6.7] - 2026-09-09
 
 ### Added

{taskledger-0.6.7 → taskledger-0.6.8}/docs/command_contract.md

@@ -178,6 +178,8 @@ Rules:
 
 - `validate command -- ...` records managed validation command evidence during an active validation run.
 - A non-zero validation command does not create a `ValidationCheck`; explicitly classify and record criteria with `validate check`.
+- A passing implementation command may be adopted explicitly as validation evidence with `validate check --from-implementation-check CHECK_ID` only when Taskledger reports an exact final/current workspace snapshot match.
+- This is evidence reuse, not a generic command cache. Rerun validation when fresh execution or external runtime state matters.
 
 ## Archive import lock policy
 

{taskledger-0.6.7 → taskledger-0.6.8}/docs/full_task_cycle.md

@@ -265,6 +265,13 @@ taskledger validate finish --result passed --summary "Parser fix validated with
 ```
 
 Use `taskledger validate command -- ...` to preserve validation command cwd, output, exit status, and transcript evidence. A non-zero command is not automatically a failed acceptance criterion. If the command is a malformed probe or setup failure, correct it and rerun before recording criterion status. Only record `fail` after the target behavior was evaluated and failed.
+When implementation checks have exact tested-state provenance, validation context and status may identify them as reusable. Record that decision explicitly, for example:
+
+```bash
+taskledger validate check --criterion ac-0001 --status pass --from-implementation-check check-0002 --details "Reused passing implementation evidence on the exact current snapshot."
+```
+
+`validate command` always executes its child command normally; it does not silently reuse implementation results.
 
 ### If validation finds a bug
 

{taskledger-0.6.7 → taskledger-0.6.8}/skills/taskledger/SKILL.md

@@ -357,6 +357,7 @@ linked-file drift checks.
 2. `taskledger validate start`
 3. Check `taskledger validate status` to see current validation state and blockers.
 4. Run verification with `taskledger validate command -- ...` whenever practical.
+   - If a passing implementation check is reported reusable for the exact current snapshot, a validator may cite it explicitly with `--from-implementation-check CHECK_ID` instead of rerunning that command.
 5. Record criterion results: `taskledger validate check --criterion ac-0001 --status pass|fail|warn|not_run --evidence "..."`
 6. Optionally waive criteria with user authority: `taskledger validate waive --criterion ac-0001 --reason "..."`.
 7. Check `taskledger validate status` again to confirm all mandatory gates pass.
@@ -397,6 +398,7 @@ not interpret those references.
 taskledger link add --url specs/behavior/features/checkout/payment.feature --label "behavior spec"
 taskledger file link specs/behavior/features/checkout/payment.feature --kind doc --label "behavior spec"
 taskledger validate check --criterion ac-0001 --status pass --evidence "pytest tests/test_checkout_payment.py::test_payment_flow"
+taskledger validate check --criterion ac-0001 --status pass --from-implementation-check check-0002 --details "Reused exact-snapshot implementation evidence"
 ```
 
 ## Required logging

{taskledger-0.6.7 → taskledger-0.6.8}/taskledger/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.6.7'
-__version_tuple__ = version_tuple = (0, 6, 7)
+__version__ = version = '0.6.8'
+__version_tuple__ = version_tuple = (0, 6, 8)
 
-__commit_id__ = commit_id = 'gfa5b2b772'
+__commit_id__ = commit_id = 'g4f9cd16f0'

{taskledger-0.6.7 → taskledger-0.6.8}/taskledger/cli_validate.py

@@ -248,6 +248,7 @@ def register_validate_v2_commands(app: typer.Typer) -> None:
         details: str | None,
         evidence: list[str] | None,
         task_ref: str | None,
+        implementation_check_refs: list[str] | None,
     ) -> None:
         state = cli_state_from_context(ctx)
         try:
@@ -260,6 +261,7 @@ def register_validate_v2_commands(app: typer.Typer) -> None:
                 status=status,
                 details=details,
                 evidence=tuple(evidence or ()),
+                implementation_check_refs=tuple(implementation_check_refs or ()),
             )
         except LaunchError as exc:
             emit_error(ctx, exc)
@@ -272,6 +274,13 @@ def register_validate_v2_commands(app: typer.Typer) -> None:
         criterion: Annotated[str, typer.Option("--criterion")],
         status: Annotated[str, typer.Option("--status")] = "pass",
         evidence: Annotated[list[str] | None, typer.Option("--evidence")] = None,
+        implementation_check_refs: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--from-implementation-check",
+                help="Explicitly adopt reusable implementation check evidence.",
+            ),
+        ] = None,
         name: Annotated[str | None, typer.Option("--name")] = None,
         details: Annotated[str | None, typer.Option("--details")] = None,
         task_ref: TaskOption = None,
@@ -284,6 +293,7 @@ def register_validate_v2_commands(app: typer.Typer) -> None:
             details=details,
             evidence=evidence,
             task_ref=task_ref,
+            implementation_check_refs=implementation_check_refs,
         )
 
     @app.command("finish")

{taskledger-0.6.7 → taskledger-0.6.8}/taskledger/domain/check.py

@@ -30,6 +30,12 @@ class ImplementationCheckRecord:
     command: str
     argv: tuple[str, ...] = ()
     exit_code: int | None = None
+    cwd: str | None = None
+    workspace_git_commit: str | None = None
+    workspace_content_hash: str | None = None
+    workspace_paths_hash: str | None = None
+    workspace_entry_count: int | None = None
+    workspace_snapshot_format: str | None = None
     status: Literal["passed", "failed", "unknown"] = "unknown"
     category: Literal[
         "test", "lint", "format", "typecheck", "build", "security", "other"
@@ -54,6 +60,12 @@ class ImplementationCheckRecord:
             "command": self.command,
             "argv": list(self.argv),
             "exit_code": self.exit_code,
+            "cwd": self.cwd,
+            "workspace_git_commit": self.workspace_git_commit,
+            "workspace_content_hash": self.workspace_content_hash,
+            "workspace_paths_hash": self.workspace_paths_hash,
+            "workspace_entry_count": self.workspace_entry_count,
+            "workspace_snapshot_format": self.workspace_snapshot_format,
             "status": self.status,
             "category": self.category,
             "summary": self.summary,
@@ -86,6 +98,14 @@ class ImplementationCheckRecord:
             timestamp=_optional_string(data.get("timestamp")) or utc_now_iso(),
             command=_string_value(data, "command"),
             argv=_string_tuple(data.get("argv")),
+            cwd=_optional_string(data.get("cwd")),
+            workspace_git_commit=_optional_string(data.get("workspace_git_commit")),
+            workspace_content_hash=_optional_string(data.get("workspace_content_hash")),
+            workspace_paths_hash=_optional_string(data.get("workspace_paths_hash")),
+            workspace_entry_count=_optional_int(data.get("workspace_entry_count")),
+            workspace_snapshot_format=_optional_string(
+                data.get("workspace_snapshot_format")
+            ),
             exit_code=_optional_int(data.get("exit_code")),
             status=cast(Literal["passed", "failed", "unknown"], status),
             category=cast(

{taskledger-0.6.7 → taskledger-0.6.8}/taskledger/domain/sidecars.py

@@ -386,6 +386,7 @@ class ValidationCheck:
     status: ValidationCheckStatus = "pass"
     details: str | None = None
     evidence: tuple[str, ...] = ()
+    implementation_check_refs: tuple[str, ...] = ()
     waiver: CriterionWaiver | None = None
 
     def to_dict(self) -> dict[str, object]:
@@ -397,6 +398,7 @@ class ValidationCheck:
             "details": self.details,
             "evidence": list(self.evidence),
             "waiver": self.waiver.to_dict() if self.waiver is not None else None,
+            "implementation_check_refs": list(self.implementation_check_refs),
         }
         return payload
 
@@ -423,6 +425,9 @@ class ValidationCheck:
             status=status,
             details=_optional_string(data.get("details")),
             evidence=_string_tuple(data.get("evidence")),
+            implementation_check_refs=_string_tuple(
+                data.get("implementation_check_refs")
+            ),
             waiver=CriterionWaiver.from_dict(data.get("waiver")),
         )
 

taskledger-0.6.8/taskledger/services/check_reuse.py

@@ -0,0 +1,240 @@
+"""Eligibility checks for reusing implementation command evidence."""
+
+from __future__ import annotations
+
+import shlex
+from dataclasses import dataclass
+from pathlib import Path
+
+from taskledger.domain.check import ImplementationCheckRecord
+from taskledger.domain.models import TaskRecord, TaskRunRecord
+from taskledger.services.workspace_snapshot import (
+    SNAPSHOT_FORMAT,
+    WorkspaceContentSnapshot,
+    capture_workspace_content_snapshot,
+)
+from taskledger.storage.task_store import list_checks, resolve_run
+
+
+@dataclass(frozen=True, slots=True)
+class CheckReuseEvaluation:
+    eligible: bool
+    reason_code: str
+    message: str
+    check_id: str
+    command: str
+    implementation_run: str
+    snapshot_match: bool
+    current_workspace_match: bool
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "eligible": self.eligible,
+            "reason_code": self.reason_code,
+            "message": self.message,
+            "check_id": self.check_id,
+            "command": self.command,
+            "implementation_run": self.implementation_run,
+            "snapshot_match": self.snapshot_match,
+            "current_workspace_match": self.current_workspace_match,
+        }
+
+
+def _evaluation(
+    check: ImplementationCheckRecord,
+    *,
+    eligible: bool = False,
+    reason_code: str,
+    message: str,
+    snapshot_match: bool = False,
+    current_workspace_match: bool = False,
+) -> CheckReuseEvaluation:
+    return CheckReuseEvaluation(
+        eligible=eligible,
+        reason_code=reason_code,
+        message=message,
+        check_id=check.check_id,
+        command=check.command,
+        implementation_run=check.implementation_run,
+        snapshot_match=snapshot_match,
+        current_workspace_match=current_workspace_match,
+    )
+
+
+def _has_check_snapshot(check: ImplementationCheckRecord) -> bool:
+    return all(
+        value is not None
+        for value in (
+            check.cwd,
+            check.workspace_git_commit,
+            check.workspace_content_hash,
+            check.workspace_paths_hash,
+            check.workspace_entry_count,
+            check.workspace_snapshot_format,
+        )
+    )
+
+
+def _has_implementation_snapshot(run: TaskRunRecord) -> bool:
+    return all(
+        value is not None
+        for value in (
+            run.workspace_git_commit,
+            run.workspace_content_hash,
+            run.workspace_paths_hash,
+            run.workspace_entry_count,
+            run.workspace_snapshot_format,
+        )
+    )
+
+
+def _check_matches_run(
+    check: ImplementationCheckRecord, run: TaskRunRecord
+) -> tuple[bool, str]:
+    if check.workspace_snapshot_format != run.workspace_snapshot_format:
+        return False, "snapshot_format_mismatch"
+    if check.workspace_git_commit != run.workspace_git_commit:
+        return False, "check_commit_mismatch"
+    if check.workspace_content_hash != run.workspace_content_hash:
+        return False, "check_content_mismatch"
+    if check.workspace_paths_hash != run.workspace_paths_hash:
+        return False, "check_content_mismatch"
+    if check.workspace_entry_count != run.workspace_entry_count:
+        return False, "check_content_mismatch"
+    return True, "eligible"
+
+
+def _current_matches_run(current: WorkspaceContentSnapshot, run: TaskRunRecord) -> bool:
+    return (
+        current.git_commit == run.workspace_git_commit
+        and current.content_hash == run.workspace_content_hash
+        and current.paths_hash == run.workspace_paths_hash
+        and current.entry_count == run.workspace_entry_count
+        and SNAPSHOT_FORMAT == run.workspace_snapshot_format
+    )
+
+
+def evaluate_implementation_check_reuse(
+    workspace_root: Path,
+    task: TaskRecord,
+    validation_run: TaskRunRecord | None,
+    check: ImplementationCheckRecord,
+    *,
+    current_state: WorkspaceContentSnapshot | None = None,
+) -> CheckReuseEvaluation:
+    """Evaluate whether an implementation check can be cited as evidence."""
+    if check.status != "passed" or check.exit_code != 0:
+        return _evaluation(
+            check,
+            reason_code="check_not_passed",
+            message="Implementation check did not pass with exit code 0.",
+        )
+
+    if validation_run is None or validation_run.based_on_implementation_run is None:
+        return _evaluation(
+            check,
+            reason_code="wrong_implementation_run",
+            message="Validation run has no implementation snapshot baseline.",
+        )
+
+    implementation_run_id = validation_run.based_on_implementation_run
+    if check.implementation_run != implementation_run_id:
+        return _evaluation(
+            check,
+            reason_code="wrong_implementation_run",
+            message="Implementation check belongs to a different implementation run.",
+        )
+
+    implementation_run = resolve_run(workspace_root, task.id, implementation_run_id)
+    if not _has_check_snapshot(check):
+        return _evaluation(
+            check,
+            reason_code="missing_check_snapshot",
+            message="Implementation check has no tested-state provenance.",
+        )
+    if not _has_implementation_snapshot(implementation_run):
+        return _evaluation(
+            check,
+            reason_code="legacy_snapshot_not_reusable",
+            message="Implementation run has no reusable content snapshot.",
+        )
+
+    snapshot_match, reason_code = _check_matches_run(check, implementation_run)
+    if not snapshot_match:
+        messages = {
+            "snapshot_format_mismatch": (
+                "Implementation check uses an incompatible snapshot format."
+            ),
+            "check_commit_mismatch": (
+                "Implementation check was run against a different Git commit."
+            ),
+            "check_content_mismatch": (
+                "Check content differs from implementation snapshot."
+            ),
+        }
+        return _evaluation(
+            check,
+            reason_code=reason_code,
+            message=messages[reason_code],
+        )
+
+    current = current_state or capture_workspace_content_snapshot(workspace_root)
+    current_workspace_match = _current_matches_run(current, implementation_run)
+    if not current_workspace_match:
+        return _evaluation(
+            check,
+            reason_code="implementation_snapshot_stale",
+            message=(
+                "Current workspace no longer matches the final implementation snapshot."
+            ),
+            snapshot_match=True,
+        )
+
+    return _evaluation(
+        check,
+        eligible=True,
+        reason_code="eligible",
+        message=(
+            "Implementation check matches the final and current workspace snapshots."
+        ),
+        snapshot_match=True,
+        current_workspace_match=True,
+    )
+
+
+def reusable_implementation_checks(
+    workspace_root: Path,
+    task: TaskRecord,
+    validation_run: TaskRunRecord | None,
+    *,
+    current_state: WorkspaceContentSnapshot | None = None,
+) -> list[CheckReuseEvaluation]:
+    """Evaluate all implementation checks for a validation run."""
+    return [
+        evaluate_implementation_check_reuse(
+            workspace_root,
+            task,
+            validation_run,
+            check,
+            current_state=current_state,
+        )
+        for check in list_checks(workspace_root, task.id)
+    ]
+
+
+def plan_command_matches_check(
+    workspace_root: Path,
+    plan_command: str,
+    check: ImplementationCheckRecord,
+) -> bool:
+    """Match a root-scoped plan command to a check without fuzzy equivalence."""
+    try:
+        plan_argv = tuple(shlex.split(plan_command))
+    except ValueError:
+        return False
+    return (
+        plan_argv == check.argv
+        and check.cwd is not None
+        and Path(check.cwd).expanduser().resolve()
+        == workspace_root.expanduser().resolve()
+    )

{taskledger-0.6.7 → taskledger-0.6.8}/taskledger/services/check_tracking.py

@@ -38,6 +38,12 @@ def add_check(
         "other",
     ] = "other",
     artifact_refs: tuple[str, ...] = (),
+    cwd: str | None = None,
+    workspace_git_commit: str | None = None,
+    workspace_content_hash: str | None = None,
+    workspace_paths_hash: str | None = None,
+    workspace_entry_count: int | None = None,
+    workspace_snapshot_format: str | None = None,
 ) -> ImplementationCheckRecord:
     task = resolve_task(workspace_root, task_ref)
     _tasks._ensure_not_archived(task, operation="record checks on")
@@ -74,6 +80,12 @@ def add_check(
         status=status,
         category=category,
         summary=(summary or "").strip() or None,
+        cwd=cwd,
+        workspace_git_commit=workspace_git_commit,
+        workspace_content_hash=workspace_content_hash,
+        workspace_paths_hash=workspace_paths_hash,
+        workspace_entry_count=workspace_entry_count,
+        workspace_snapshot_format=workspace_snapshot_format,
     )
     save_check(workspace_root, check)
     save_run(

{taskledger-0.6.7 → taskledger-0.6.8}/taskledger/services/doctor_checks/task_checks.py

@@ -40,6 +40,7 @@ def _scan_task_integrity_phases(  # noqa: C901
     from taskledger.storage.task_store import (
         change_markdown_path,
         list_changes,
+        list_checks,
         list_handoffs_with_errors,
         list_plans,
         load_requirements,
@@ -291,6 +292,9 @@ def _scan_task_integrity_phases(  # noqa: C901
                 )
 
         # Validation run checks
+        implementation_check_ids = {
+            check.check_id for check in list_checks(workspace_root, task.id)
+        }
         for run in task_runs[task.id]:
             if run.run_type == "validation" and run.based_on_implementation_run:
                 linked = run_map.get((task.id, run.based_on_implementation_run))
@@ -354,6 +358,17 @@ def _scan_task_integrity_phases(  # noqa: C901
                             ),
                         ],
                     )
+            for validation_check in run.checks:
+                for (
+                    implementation_check_id
+                ) in validation_check.implementation_check_refs:
+                    if implementation_check_id not in implementation_check_ids:
+                        errors.append(
+                            f"Validation check {validation_check.id} in "
+                            f"task {task.id} "
+                            f"references missing implementation check "
+                            f"{implementation_check_id}."
+                        )
 
 
 def scan_task_integrity(