What 815 million tokens taught me about AI-DLC

Title: Verify the combined tree
Applies when: related tasks run in separate checkouts.
Practice: run the project verification again after combining the changes.
Evidence: link to the failure, fix, and verification result.
Recheck when: the build, test scope, or integration process changes.

Investigate → verify → remember the decision
Stable operation → review and verify a script → retain it
Next relevant task → recall → check applicability → use it

For unfamiliar technical behavior, do not rely on general model knowledge.
Consult an approved documentation or registry MCP before answering or acting.
Check the target version and cite the source supporting the claim.
Mark gaps UNVERIFIED and resolve them before a consequential change.
Recall earlier decisions, then check that their evidence still applies.

- [ ] T001 Establish the security baseline and agree the export contract
- [ ] T002 [depends: T001] Export filtered records as CSV [P]
- [ ] T003 [depends: T001] Export filtered records as JSON [P]
- [ ] T004 [depends: T002, T003] Verify both export formats together

# guard: check_secrets
def check_secrets(file_path, tool_input, scan):
    import json
    from pathlib import Path
    name = Path(file_path).name
    examples = {".env.example", ".env.template", ".env.sample", ".env.dist"}
    if name == ".env" or (name.startswith(".env.") and name not in examples):
        return "Use an example environment file; keep real credentials outside the task."
    try:
        found = scan(json.dumps(tool_input, ensure_ascii=False))
    except Exception:
        return "The secret check could not run."
    if found is not False:
        return "Tool input could not be cleared by the secret check."

# guard: guard_cloud_access
def guard_cloud_access(profile, region, credential_override, pinned):
    if credential_override:
        return "Use the approved credential configuration."
    if not all(pinned) or (profile, region) != pinned:
        return "The cloud profile or region does not match this project's policy."

# guard: guard_verified_binding
def guard_verified_binding(profile, expected_account):
    import json
    import subprocess
    if not profile or not expected_account:
        return "The project has no verified account binding."
    try:
        result = subprocess.run(
            ["aws", "sts", "get-caller-identity", "--profile", profile, "--output", "json"],
            check=True, capture_output=True, text=True, timeout=10,
        )
        actual = json.loads(result.stdout)["Account"]
    except Exception:
        return "The account identity could not be verified."
    if actual != expected_account:
        return "The resolved account does not match the project binding."

# guard: guard_no_autonomous_apply
def guard_no_autonomous_apply(executable, arguments):
    from pathlib import Path
    program = Path(executable).name
    if program in {"apply.sh", "destroy.sh", "bootstrap.sh"}:
        return "A human must run this deployment step."
    if program == "terraform" and {"apply", "destroy"}.intersection(arguments):
        return "Prepare the plan and leave execution to a human."

# guard: guard_mcp_tools
def guard_mcp_tools(tool_name, tool_input):
    if not tool_name.startswith("mcp__"):
        return
    allowed = {"mcp__catalog__resource": {"read", "describe"}}
    operation = tool_input.get("operation")
    if not isinstance(operation, str) or operation not in allowed.get(tool_name, set()):
        return "This MCP tool or operation is outside the approved scope."

# guard: guard_paths
def guard_paths(file_path, cwd, approved_roots):
    from pathlib import Path
    path = Path(file_path)
    target = (path if path.is_absolute() else Path(cwd) / path).resolve()
    if not any(target.is_relative_to(Path(root).resolve()) for root in approved_roots):
        return "Choose a path inside the approved workspace."

# guard: guard_meta
def guard_meta(relative_path):
    exact = {"guard-policy.json", ".claude/settings.json", ".claude/settings.local.json"}
    trees = (".claude/hooks", "plugins/guards")
    if relative_path in exact or any(
        relative_path == root or relative_path.startswith(root + "/") for root in trees
    ):
        return "A human must change guard policy or wiring."

# guard: guard_test_immutability
def guard_test_immutability(affected_paths, baseline_tests):
    if set(affected_paths).intersection(baseline_tests):
        return "Preserve the baseline tests; add coverage or request a test change."

# guard: guard_tmp_confinement
def guard_tmp_confinement(absolute_path, project_root, system_temp_roots):
    from pathlib import Path
    target = Path(absolute_path).resolve()
    if target.is_relative_to(Path(project_root).resolve()):
        return
    if any(target.is_relative_to(Path(root).resolve()) for root in system_temp_roots):
        return "Put agent-authored scratch files in the project's ignored .tmp/ directory."

# guard: guard_git_remote
def guard_git_remote(effective_urls, approved_urls):
    if not effective_urls or not set(effective_urls).issubset(approved_urls):
        return "Use a Git destination approved for this project."

# guard: guard_commit_hygiene
def guard_commit_hygiene(subcommand, flags, pathspecs):
    flags, paths = set(flags), set(pathspecs)
    if subcommand == "add" and (
        flags.intersection({"-A", "--all", "-u", "--update"})
        or paths.intersection({".", ":/", "*"})
    ):
        return "Stage explicit paths for this task."
    if subcommand == "commit" and flags.intersection({"-a", "--all"}):
        return "Review and stage the intended changes before committing."

# guard: guard_sprint_conventions
def guard_sprint_conventions(branch, first_commit, message, destination_refs):
    import re
    if not re.fullmatch(r"exercise/[a-z0-9][a-z0-9-]*", branch):
        return "Use the agreed exercise branch naming."
    if first_commit and not message.startswith("[baseline] "):
        return "Mark the initial baseline commit."
    if any(ref != f"refs/heads/{branch}" for ref in destination_refs):
        return "Push only to the agreed exercise branch."

# adapter: mcp_pre_tool_use
import json
import sys

try:
    event = json.load(sys.stdin)
    reason = guard_mcp_tools(event["tool_name"], event["tool_input"])
except Exception:
    reason = "The guard could not validate this tool request."

if reason:
    print(reason, file=sys.stderr)
    raise SystemExit(2)

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "mcp__.*",
        "hooks": [
          {
            "type": "command",
            "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/mcp_guard.py\""
          }
        ]
      }
    ]
  }
}

printf '%s\n' '{"tool_name":"mcp__catalog__resource","tool_input":{"operation":"delete"}}' \
  | python3 .claude/hooks/mcp_guard.py