Sync GitHub commit 62cbb0b

Mirror the docs-drift runnable implementation, regression checks, memory lifecycle reference, and maintenance documentation from GitHub main.

.github/workflows/quality.yml

@@ -37,6 +37,11 @@ jobs:
       - name: Install brand asset dependency
         run: python -m pip install "Pillow>=10.4,<13"
 
+      - name: Check runnable loop examples
+        run: |
+          python scripts/check_runnable_examples.py
+          python scripts/check_url_checker.py
+
       - name: Check Markdown formatting
         uses: DavidAnson/markdownlint-cli2-action@v17
         with:

.gitignore

@@ -1,4 +1,5 @@
 __pycache__/
 *.py[cod]
+.loop-state/
 output/
 .playwright-cli/

README.zh-CN.md

@@ -28,7 +28,7 @@
 
 Prompt engineering 改进你对模型说什么。Context engineering 改进模型能看到什么。Harness engineering 改进单次 agent 运行周围的工具、权限、沙箱和检查。**Loop Engineering 位于三者之上**：人不再逐轮手动提示 agent，而是设计一个循环系统，让它负责提示、监督、验证、更新状态并再次触发 agents。
 
-一个 loop 会发现工作、分派给一个或多个 agents、检查结果、记录状态、决定下一步，并按照节奏或直到满足可验证目标为止持续运行。
+一个 loop 会发现工作、分派给一个或多个 agents、检查结果、留下可审查的运行凭证（receipts）、更新状态并决定下一步；它按既定节奏重复运行，或在达到可验证目标后停止。
 
 Loop Engineering 专指具备明确触发、外部验证和持久状态的可重复 AI-agent 与 coding-agent 系统，不包括软件事件循环、控制论、增长循环、通用 workflow automation 或非 AI feedback loop。
 
@@ -56,7 +56,7 @@ Prompt、context 和 harness engineering 让单次 agent 运行更好。Loop Eng
 | Context           | 哪些知识应该长期存在？    | `AGENTS.md`、`CLAUDE.md`、`SKILL.md`、docs               |
 | Delegation        | 哪个 agent 负责什么？ | explorer、implementer、reviewer、judge                   |
 | Verification      | 什么机制判断通过或失败？   | tests、typecheck、lint、evals、trace graders              |
-| State             | 下一轮需要保留什么？     | progress file、checkpoint、trace、issue comment          |
+| State             | 下一轮需要保留什么？     | progress file、checkpoint、trace、运行凭证（receipt）        |
 | Budget            | 何时停止消耗？        | max turns、max retries、token budget、time box           |
 | Escalation        | 何时交给人？         | PR、issue、Slack alert、triage inbox                     |
 | Exit              | loop 如何知道完成？   | acceptance criteria、passing checks、no work found      |

examples/runnable/README.md

@@ -1,6 +1,6 @@
 # Runnable Loop Starters
 
-Eight implementation starters connect a loop contract to a runtime. Three are dependency-light executables; five are copy/paste runtime templates with concrete prompts, schedules, permissions, state, and stop conditions.
+Eight general-purpose starters connect a loop contract to a runtime. Three are dependency-light executables; five are copy/paste runtime templates with concrete prompts, schedules, permissions, state, and stop conditions. A nested worked implementation shows how to specialize these primitives without pretending every use case is a new runtime.
 
 Each starter keeps the control loop visible: permissions, verification, state, and budgets remain explicit instead of disappearing inside a framework.
 
@@ -116,6 +116,49 @@ A timed-out agent or verifier consumes one attempt and leaves a receipt before t
 - **Evidence stops waste.** Repeated failures and threshold breaches stop or escalate instead of consuming an open-ended budget.
 - **Permissions remain visible.** The starters expect a branch, worktree, sandbox, or read-only boundary rather than pretending isolation is automatic.
 
+## Worked Implementation: Scheduled Docs Drift
+
+[`docs-drift/docs-drift-loop.py`](docs-drift/docs-drift-loop.py) specializes the [shell / cron starter](shell-cron-loop.md) for the [docs-drift pattern](../../patterns/docs-drift-collector.md) and [validated contract](../docs-drift-loop.json). The detector, acting agent, and verifier remain separate:
+
+- the detector exits `0` when docs are current, `1` with evidence when drift is confirmed, and any other code on detector failure;
+- report-only mode stores an evidence receipt and exits `2` for human triage;
+- patch mode gives the evidence to an agent, enforces allowed and generated paths plus a file-count budget, then lets an independent command decide success;
+- every outcome is appended to `.loop-state/docs-drift.jsonl`, which is ignored by Git but survives model calls;
+- the script never commits, pushes, merges, changes a verifier, or reverts an unsafe edit behind the operator's back.
+
+Run the detector without invoking an agent or writing state:
+
+```bash
+python3 examples/runnable/docs-drift/docs-drift-loop.py \
+  --discover-command "python3 scripts/check_project_consistency.py" \
+  --dry-run
+```
+
+Produce a scheduled evidence-backed report:
+
+```bash
+python3 examples/runnable/docs-drift/docs-drift-loop.py \
+  --discover-command "python3 scripts/check_project_consistency.py" \
+  --report-only
+```
+
+Patch confirmed drift inside a clean branch or worktree:
+
+```bash
+python3 examples/runnable/docs-drift/docs-drift-loop.py \
+  --discover-command "python3 scripts/check_project_consistency.py" \
+  --agent-command "codex exec" \
+  --verify-command "python3 scripts/check_project_consistency.py" \
+  --allowed-path README.md \
+  --allowed-path docs \
+  --allowed-path meta \
+  --max-attempts 2 \
+  --max-changed-files 8 \
+  --command-timeout 900
+```
+
+Copy [`docs-drift/github-actions.yml`](docs-drift/github-actions.yml) into `.github/workflows/` for a read-only Monday schedule that uploads the JSONL receipt. For cron, run the report-only command from the repository root and send exit code `2` to the docs owner. Add `--generated-path <path>` for files that must be regenerated or reviewed rather than edited directly.
+
 ## Smoke Checks
 
 Run these without an agent account:
@@ -123,6 +166,7 @@ Run these without an agent account:
 ```bash
 bash -n test-repair-loop.sh threshold-monitor-loop.sh
 python3 -m py_compile queue-worker-loop.py
+python3 ../../scripts/check_runnable_examples.py
 printf '%s\n' '{"id":"demo","objective":"Validate the queue"}' > /tmp/loop-queue.jsonl
 python3 queue-worker-loop.py --queue /tmp/loop-queue.jsonl --dry-run
 PROBE_CMD="printf '42\\n'" THRESHOLD=100 MAX_SAMPLES=1 ./threshold-monitor-loop.sh

examples/runnable/docs-drift/docs-drift-loop.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""Run a bounded documentation-drift loop with external verification.
+
+The discovery command owns the drift decision: exit 0 means no confirmed drift,
+exit 1 means confirmed drift and its output is evidence, and any other exit code
+is a detector error. The script can write a report only or delegate a patch to
+an agent CLI, enforce a path and file-count boundary, run an independent
+verifier, and persist every outcome as JSONL outside the model context.
+
+Run this only in a clean branch or worktree. The script never commits, pushes,
+merges, edits generated files itself, or weakens a verifier.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import fnmatch
+import hashlib
+import json
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+
+EXIT_OK = 0
+EXIT_ESCALATED = 2
+EXIT_ERROR = 3
+
+
+def utc_now() -> str:
+    return dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds")
+
+
+def command_argv(command: str) -> list[str]:
+    argv = shlex.split(command)
+    if not argv:
+        raise ValueError("command cannot be empty")
+    return argv
+
+
+def run_command(
+    command: str,
+    *,
+    workdir: Path,
+    timeout: int,
+    final_argument: str | None = None,
+) -> subprocess.CompletedProcess[str]:
+    argv = command_argv(command)
+    if final_argument is not None:
+        argv.append(final_argument)
+    return subprocess.run(
+        argv,
+        cwd=workdir,
+        text=True,
+        capture_output=True,
+        check=False,
+        timeout=timeout,
+    )
+
+
+def combined_output(result: subprocess.CompletedProcess[str], *, max_lines: int) -> str:
+    output = "\n".join(part.strip() for part in (result.stdout, result.stderr) if part.strip())
+    return "\n".join(output.splitlines()[-max_lines:])
+
+
+def append_receipt(path: Path, receipt: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(receipt, ensure_ascii=True, sort_keys=True) + "\n")
+
+
+def evidence_digest(evidence: str) -> str:
+    return hashlib.sha256(evidence.encode("utf-8")).hexdigest()[:16]
+
+
+def git_paths(workdir: Path) -> set[str]:
+    commands = (
+        ["git", "diff", "--name-only", "--relative"],
+        ["git", "diff", "--cached", "--name-only", "--relative"],
+        ["git", "ls-files", "--others", "--exclude-standard"],
+    )
+    paths: set[str] = set()
+    for argv in commands:
+        result = subprocess.run(argv, cwd=workdir, text=True, capture_output=True, check=False)
+        if result.returncode != 0:
+            raise RuntimeError(result.stderr.strip() or "workdir is not a Git repository")
+        paths.update(line.strip() for line in result.stdout.splitlines() if line.strip())
+    return paths
+
+
+def path_matches(path: str, boundary: str) -> bool:
+    normalized_path = Path(path).as_posix().removeprefix("./")
+    normalized_boundary = Path(boundary).as_posix().removeprefix("./").rstrip("/")
+    if any(character in normalized_boundary for character in "*?["):
+        return fnmatch.fnmatch(normalized_path, normalized_boundary)
+    return normalized_path == normalized_boundary or normalized_path.startswith(normalized_boundary + "/")
+
+
+def receipt_base(run_id: str, status: str, evidence: str) -> dict[str, Any]:
+    return {
+        "run_id": run_id,
+        "status": status,
+        "timestamp": utc_now(),
+        "evidence_digest": evidence_digest(evidence),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--discover-command", required=True, help="exit 0 for no drift, 1 for confirmed drift")
+    parser.add_argument("--agent-command", help="agent CLI; the bounded patch prompt is appended as one argument")
+    parser.add_argument("--verify-command", help="deterministic command that must pass after an agent edit")
+    parser.add_argument("--workdir", type=Path, default=Path.cwd(), help="clean Git branch or worktree")
+    parser.add_argument(
+        "--state",
+        type=Path,
+        default=Path(".loop-state/docs-drift.jsonl"),
+        help="durable JSONL receipt log",
+    )
+    parser.add_argument("--allowed-path", action="append", default=[], help="allowed file or directory; repeat as needed")
+    parser.add_argument(
+        "--generated-path",
+        action="append",
+        default=[],
+        help="generated path requiring owner review; repeat as needed",
+    )
+    parser.add_argument("--max-attempts", type=int, default=2, help="maximum agent attempts")
+    parser.add_argument("--max-changed-files", type=int, default=8, help="hard file-count boundary")
+    parser.add_argument("--command-timeout", type=int, default=900, help="seconds allowed per command")
+    parser.add_argument("--evidence-lines", type=int, default=120, help="maximum detector/verifier lines in a prompt")
+    parser.add_argument("--report-only", action="store_true", help="persist drift evidence and escalate without an agent")
+    parser.add_argument("--dry-run", action="store_true", help="run discovery and print the decision without writing state")
+    args = parser.parse_args()
+
+    if min(args.max_attempts, args.max_changed_files, args.command_timeout, args.evidence_lines) < 1:
+        parser.error("budgets and evidence-lines must be positive")
+
+    workdir = args.workdir.resolve()
+    state = args.state if args.state.is_absolute() else workdir / args.state
+    run_id = dt.datetime.now(dt.timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
+    try:
+        discovery = run_command(args.discover_command, workdir=workdir, timeout=args.command_timeout)
+    except (OSError, ValueError, subprocess.TimeoutExpired) as error:
+        evidence = f"discovery could not complete: {error}"
+        if not args.dry_run:
+            append_receipt(state, {**receipt_base(run_id, "escalated", evidence), "reason": evidence})
+        print(f"[docs-drift] {evidence}", file=sys.stderr)
+        return EXIT_ERROR
+
+    evidence = combined_output(discovery, max_lines=args.evidence_lines)
+    if discovery.returncode == 0:
+        decision = {"run_id": run_id, "status": "no_drift", "detector_exit": 0}
+        if args.dry_run:
+            print(json.dumps(decision, indent=2))
+        else:
+            append_receipt(state, {**receipt_base(run_id, "no_drift", evidence), "detector_exit": 0})
+            print("[docs-drift] no confirmed drift")
+        return EXIT_OK
+
+    if discovery.returncode != 1 or not evidence:
+        reason = (
+            f"detector exited {discovery.returncode}; expected 0 (clean) or 1 (drift)"
+            if discovery.returncode != 1
+            else "detector reported drift without evidence"
+        )
+        if not args.dry_run:
+            append_receipt(
+                state,
+                {
+                    **receipt_base(run_id, "escalated", evidence or reason),
+                    "detector_exit": discovery.returncode,
+                    "reason": reason,
+                },
+            )
+        print(f"[docs-drift] {reason}", file=sys.stderr)
+        return EXIT_ERROR
+
+    if args.dry_run:
+        print(
+            json.dumps(
+                {
+                    "run_id": run_id,
+                    "status": "drift_detected",
+                    "detector_exit": discovery.returncode,
+                    "evidence": evidence,
+                },
+                indent=2,
+            )
+        )
+        return EXIT_OK
+
+    if args.report_only:
+        append_receipt(
+            state,
+            {
+                **receipt_base(run_id, "reported", evidence),
+                "detector_exit": discovery.returncode,
+                "evidence": evidence,
+                "reason": "confirmed drift requires a patch or owner decision",
+            },
+        )
+        print(evidence)
+        print("[docs-drift] report persisted; escalating", file=sys.stderr)
+        return EXIT_ESCALATED
+
+    if not args.agent_command or not args.verify_command or not args.allowed_path:
+        parser.error("patch mode requires --agent-command, --verify-command, and at least one --allowed-path")
+
+    try:
+        dirty_before = git_paths(workdir)
+    except RuntimeError as error:
+        append_receipt(state, {**receipt_base(run_id, "escalated", evidence), "reason": str(error)})
+        print(f"[docs-drift] {error}", file=sys.stderr)
+        return EXIT_ERROR
+
+    if dirty_before:
+        reason = "workdir must be clean before patch mode: " + ", ".join(sorted(dirty_before))
+        append_receipt(state, {**receipt_base(run_id, "escalated", evidence), "reason": reason})
+        print(f"[docs-drift] {reason}", file=sys.stderr)
+        return EXIT_ESCALATED
+
+    try:
+        state_relative = state.resolve().relative_to(workdir)
+    except ValueError:
+        state_relative = None
+    if state_relative is not None:
+        ignored = subprocess.run(
+            ["git", "check-ignore", "--quiet", state_relative.as_posix()],
+            cwd=workdir,
+            check=False,
+        )
+        if ignored.returncode != 0:
+            reason = "state path must be outside the worktree or ignored by Git: " + state_relative.as_posix()
+            print(f"[docs-drift] {reason}", file=sys.stderr)
+            return EXIT_ERROR
+
+    previous_verify_digest = ""
+    for attempt in range(1, args.max_attempts + 1):
+        prompt = "\n".join(
+            [
+                "You are the implementer inside a bounded documentation-drift loop.",
+                "",
+                "Confirmed detector evidence:",
+                "---",
+                evidence,
+                "---",
+                "",
+                f"Attempt: {attempt} of {args.max_attempts}",
+                "Allowed paths: " + ", ".join(args.allowed_path),
+                "Generated or owner-controlled paths: " + (", ".join(args.generated_path) or "none declared"),
+                "",
+                "Rules:",
+                "- Confirm the mismatch against code, tests, schema, or runtime output before editing.",
+                "- Make the smallest source-document change that resolves the confirmed mismatch.",
+                "- Do not edit generated or owner-controlled paths; report the source that must be regenerated.",
+                "- Do not change product behavior, public APIs, tests, policies, or verification commands.",
+                "- Do not commit, push, merge, expose credentials, or expand permissions.",
+                "- Do not decide completion; the loop runs an independent verifier.",
+            ]
+        )
+
+        try:
+            agent = run_command(
+                args.agent_command,
+                workdir=workdir,
+                timeout=args.command_timeout,
+                final_argument=prompt,
+            )
+        except (OSError, ValueError, subprocess.TimeoutExpired) as error:
+            append_receipt(
+                state,
+                {
+                    **receipt_base(run_id, "retry", evidence),
+                    "attempt": attempt,
+                    "reason": f"agent could not complete: {error}",
+                },
+            )
+            continue
+
+        try:
+            changed = sorted(git_paths(workdir))
+        except RuntimeError as error:
+            append_receipt(state, {**receipt_base(run_id, "escalated", evidence), "reason": str(error)})
+            return EXIT_ERROR
+
+        outside = [path for path in changed if not any(path_matches(path, item) for item in args.allowed_path)]
+        generated = [path for path in changed if any(path_matches(path, item) for item in args.generated_path)]
+        if len(changed) > args.max_changed_files or outside or generated:
+            reasons: list[str] = []
+            if len(changed) > args.max_changed_files:
+                reasons.append(f"{len(changed)} files exceed the {args.max_changed_files}-file budget")
+            if outside:
+                reasons.append("out-of-scope paths: " + ", ".join(outside))
+            if generated:
+                reasons.append("generated or owner-controlled paths: " + ", ".join(generated))
+            reason = "; ".join(reasons)
+            append_receipt(
+                state,
+                {
+                    **receipt_base(run_id, "escalated", evidence),
+                    "attempt": attempt,
+                    "changed_paths": changed,
+                    "reason": reason,
+                },
+            )
+            print(f"[docs-drift] {reason}; inspect the worktree", file=sys.stderr)
+            return EXIT_ESCALATED
+
+        if agent.returncode != 0:
+            agent_evidence = combined_output(agent, max_lines=args.evidence_lines)
+            append_receipt(
+                state,
+                {
+                    **receipt_base(run_id, "retry", agent_evidence or evidence),
+                    "attempt": attempt,
+                    "agent_exit": agent.returncode,
+                    "changed_paths": changed,
+                    "reason": "agent command failed",
+                },
+            )
+            evidence = agent_evidence or evidence
+            continue
+
+        if not changed:
+            append_receipt(
+                state,
+                {
+                    **receipt_base(run_id, "retry", evidence),
+                    "attempt": attempt,
+                    "agent_exit": agent.returncode,
+                    "changed_paths": [],
+                    "reason": "agent produced no file change",
+                },
+            )
+            continue
+
+        try:
+            verification = run_command(args.verify_command, workdir=workdir, timeout=args.command_timeout)
+        except (OSError, ValueError, subprocess.TimeoutExpired) as error:
+            verify_evidence = f"verifier could not complete: {error}"
+            verify_exit = None
+        else:
+            verify_evidence = combined_output(verification, max_lines=args.evidence_lines)
+            verify_exit = verification.returncode
+
+        receipt = {
+            **receipt_base(run_id, "verified" if verify_exit == 0 else "retry", verify_evidence or evidence),
+            "attempt": attempt,
+            "agent_exit": agent.returncode,
+            "verify_exit": verify_exit,
+            "changed_paths": changed,
+            "verification": verify_evidence,
+        }
+        append_receipt(state, receipt)
+
+        if verify_exit == 0:
+            print("[docs-drift] patch passed the external verifier")
+            return EXIT_OK
+
+        current_digest = evidence_digest(verify_evidence)
+        if current_digest == previous_verify_digest:
+            evidence = verify_evidence or evidence
+            break
+        previous_verify_digest = current_digest
+        evidence = verify_evidence or evidence
+
+    reason = "retry budget exhausted or verifier evidence repeated"
+    append_receipt(state, {**receipt_base(run_id, "escalated", evidence), "reason": reason})
+    print(f"[docs-drift] {reason}; inspect the worktree", file=sys.stderr)
+    return EXIT_ESCALATED
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

examples/runnable/docs-drift/github-actions.yml

@@ -0,0 +1,31 @@
+name: Scheduled docs drift report
+
+on:
+  schedule:
+    - cron: "17 3 * * 1"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  detect:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: Detect confirmed metadata drift
+        run: >-
+          python3 examples/runnable/docs-drift/docs-drift-loop.py
+          --discover-command "python3 scripts/check_project_consistency.py"
+          --report-only
+      - name: Upload the evidence receipt
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: docs-drift-receipt
+          path: .loop-state/docs-drift.jsonl
+          if-no-files-found: ignore

gallery/README.md

@@ -19,6 +19,7 @@ These entries are reference examples, not claimed production deployments. They s
 - [PR babysitter reference loop](pr-babysitter-reference.md)
 - [CI repair reference loop](ci-repair-reference.md)
 - [Docs drift reference loop](docs-drift-reference.md)
+- [Agent memory lifecycle reference loop](agent-memory-lifecycle-reference.md) - Community-proposed design with explicit provenance and no deployment claim.
 
 ## Quality Bar
 

gallery/agent-memory-lifecycle-reference.md

@@ -0,0 +1,64 @@
+# Agent Memory Lifecycle Reference Loop
+
+## Summary
+
+A reference design for carrying useful state across recurring agent runs without turning raw transcripts into permanent, ungoverned memory. The loop admits explicit records, recalls only task-relevant state, audits contradictions and retention rules, consolidates duplicates, and forgets or redacts records when policy requires it.
+
+This is a design reference, not a claimed production deployment. It was adapted from [TerminallyLazy's public pattern proposal](https://github.com/ChaoYue0307/awesome-loop-engineering/issues/7); the linked Tree Ring Memory project is an illustrative implementation, not an adoption or reliability claim.
+
+## Runtime Or Tooling
+
+- Runtime: any scheduled, event-driven, or manually bootstrapped agent runtime with a durable local or service-backed store.
+- Agent system: operator, bounded worker, memory curator, independent verifier, and human owner.
+- Illustrative tooling: [Tree Ring Memory](https://github.com/TerminallyLazy/Tree-Ring-Memory), SQLite/FTS, a project ledger, or another inspectable memory store with deletion support.
+- Repository or environment: recurring coding, documentation, release, outreach, or operations work where cold starts cause repeated discovery.
+
+## Loop Contract
+
+- Objective: preserve useful, attributable lessons between runs while preventing stale, sensitive, contradictory, or irrelevant state from silently steering future work.
+- Trigger: before and after a bounded agent run, plus a scheduled audit and consolidation pass.
+- Discover / intake: the current task, project instructions, approved prior records, public receipts, and explicit operator corrections; never silent terminal or transcript capture.
+- Workspace: a scoped project store separate from model context, with retention and access rules reviewed before unattended use.
+- Context: task identity, source links, timestamps, confidence, access class, expiry, contradiction links, and the last audit decision.
+- Delegation: the operator selects relevant records, the worker acts, the curator proposes writes or consolidation, the verifier checks receipts and policy, and the human owns sensitive or ambiguous decisions.
+- Verification: schema and provenance checks, duplicate and contradiction search, retention-policy checks, deterministic project tests, and public or local receipts for consequential actions.
+- State: append-only memory records plus indexes, tombstones, consolidation links, audit decisions, and the next review time.
+- Budget: cap recalled records, new writes, consolidation operations, and retries per run; stop when the same contradiction or policy failure repeats.
+- Escalation: credentials, private data, legal or license questions, conflicting operator decisions, deletion uncertainty, or any memory that would authorize a higher-impact action.
+- Exit: the task is externally verified and the memory delta is accepted, or the run stops with an evidence-backed report and named human owner.
+
+## Loop Instruction Or Automation
+
+```text
+Before acting, recall only approved records relevant to the current task and cite their IDs.
+After acting, propose explicit memory writes with source, timestamp, confidence, retention,
+and contradiction links. Run project verification and memory-policy checks independently.
+Persist accepted receipts and tombstones outside the model. Never store secrets or raw
+transcripts by default. Escalate ambiguous, sensitive, stale, or conflicting state.
+```
+
+## Receipts
+
+- Pattern proposal: [issue #7](https://github.com/ChaoYue0307/awesome-loop-engineering/issues/7).
+- Inspectable implementation: [Tree Ring Memory source](https://github.com/TerminallyLazy/Tree-Ring-Memory).
+- Implementation snapshot: [Tree Ring Memory v0.11.0](https://github.com/TerminallyLazy/Tree-Ring-Memory/releases/tag/v0.11.0).
+- A real deployment should additionally retain task IDs, recalled record IDs, accepted and rejected writes, verifier commands, tombstones, and the human escalation decision.
+
+No production run receipt was supplied with the proposal, so this entry does not claim measured reliability, adoption, or deployed outcomes.
+
+## Worked Scenario
+
+A weekly PR-maintenance loop repeatedly rediscovers that generated API files must be updated through a source schema and that one flaky integration test needs a fixed seed. Before each run, it recalls only those two source-linked records. After a verified patch, it records the PR URL and passing command but rejects a proposed transcript summary that contains an access token. When the schema workflow changes, the curator links the old instruction to a tombstone and writes a replacement instead of leaving both active.
+
+## Lessons Learned
+
+- Useful memory is a governed state transition, not a transcript dump.
+- Recall needs a relevance and access boundary; more context can preserve stale or conflicting instructions.
+- Writes need provenance, retention, and deletion semantics before an unattended loop can trust them.
+- Public receipts and deterministic checks should validate consequential memories; the memory tool must not certify its own downstream result.
+
+## Safety Notes
+
+- Sensitive actions: storing credentials, private conversations, customer data, identity-bound decisions, or records that expand permissions.
+- Human approvals: required for sensitive retention, ambiguous contradictions, destructive forgetting, and any memory used to authorize a high-impact action.
+- Data or privacy constraints: default to explicit writes, least retention, scoped recall, inspectable exports, and tested redaction or deletion.

meta/MAINTENANCE.md

@@ -75,6 +75,8 @@ python3 scripts/check_project_consistency.py
 python3 scripts/build_hf_card.py --check
 python3 scripts/check_publication_metadata.py
 python3 scripts/check_loop_contract_examples.py
+python3 scripts/check_runnable_examples.py
+python3 scripts/check_url_checker.py
 python3 scripts/check_pages_metadata.py
 python3 scripts/check_internal_links.py
 python3 scripts/check_commit_identity.py

posts/launch.zh-CN.md

@@ -35,6 +35,8 @@ v0.8.0 将这些层级连接起来：
 1. 当工作需要跨事件、会话或时间重复时，使用 operational pattern 与 Loop Contract。
 1. 用外部证据、持久状态、硬预算与 human escalation 管理真实世界中的重复执行。
 
+每次运行都应留下可审查的凭证（receipts），让下一轮和 human owner 能判断发生了什么、哪些 gate 已通过，以及为什么继续、升级或停止。
+
 目标仍然不是无限自治，而是有边界、可审阅、由证据驱动的重复运行。
 
 ## 浏览与复用

scripts/check_commit_identity.py

@@ -11,25 +11,29 @@ OWNER_NAME = "ChaoYue0307"
 OWNER_EMAIL = "hechaoyue0307@gmail.com"
 
 
-def git(*args: str) -> str:
-    return subprocess.check_output(["git", *args], text=True).strip()
+def commit_records() -> list[tuple[str, str, str, str, str, str]]:
+    record_format = "%H%x00%an%x00%ae%x00%cn%x00%ce%x00%B%x00"
+    raw = subprocess.check_output(["git", "log", "-z", f"--format={record_format}"])
+    records: list[tuple[str, str, str, str, str, str]] = []
+    for raw_record in raw.split(b"\x00\x00"):
+        if not raw_record:
+            continue
+        fields = raw_record.decode("utf-8").split("\x00", 5)
+        if len(fields) != 6:
+            raise ValueError("could not parse a commit identity record")
+        records.append((fields[0], fields[1], fields[2], fields[3], fields[4], fields[5]))
+    return records
 
 
 def main() -> int:
     try:
-        commits = git("rev-list", "HEAD").splitlines()
-    except subprocess.CalledProcessError as error:
+        commits = commit_records()
+    except (subprocess.CalledProcessError, UnicodeDecodeError, ValueError) as error:
         print(f"Could not inspect git history: {error}", file=sys.stderr)
         return 1
 
     failures: list[str] = []
-    for commit in commits:
-        author_name = git("show", "-s", "--format=%an", commit)
-        author_email = git("show", "-s", "--format=%ae", commit)
-        committer_name = git("show", "-s", "--format=%cn", commit)
-        committer_email = git("show", "-s", "--format=%ce", commit)
-        message = git("show", "-s", "--format=%B", commit)
-
+    for commit, author_name, author_email, committer_name, committer_email, message in commits:
         if (author_name, author_email) != (OWNER_NAME, OWNER_EMAIL):
             failures.append(f"{commit}: unexpected author {author_name} <{author_email}>")
         if (committer_name, committer_email) != (OWNER_NAME, OWNER_EMAIL):

scripts/check_runnable_examples.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""Smoke-test the dependency-light runnable loop examples."""
+
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+RUNNABLE = ROOT / "examples" / "runnable"
+DOCS_DRIFT = RUNNABLE / "docs-drift" / "docs-drift-loop.py"
+
+
+def run(
+    argv: list[str],
+    *,
+    cwd: Path = ROOT,
+    env: dict[str, str] | None = None,
+    expected: tuple[int, ...] = (0,),
+) -> subprocess.CompletedProcess[str]:
+    result = subprocess.run(argv, cwd=cwd, env=env, text=True, capture_output=True, check=False, timeout=30)
+    if result.returncode not in expected:
+        raise RuntimeError(
+            f"command failed ({result.returncode}): {shlex.join(argv)}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+        )
+    return result
+
+
+def write(path: Path, text: str) -> None:
+    path.write_text(text, encoding="utf-8")
+
+
+def main() -> int:
+    run(["bash", "-n", str(RUNNABLE / "test-repair-loop.sh"), str(RUNNABLE / "threshold-monitor-loop.sh")])
+    run([sys.executable, "-m", "py_compile", str(RUNNABLE / "queue-worker-loop.py"), str(DOCS_DRIFT)])
+
+    with tempfile.TemporaryDirectory(prefix="ale-runnable-") as temporary:
+        temp = Path(temporary)
+        queue = temp / "queue.jsonl"
+        write(queue, '{"id":"docs-1","objective":"Check the docs"}\n')
+        run([sys.executable, str(RUNNABLE / "queue-worker-loop.py"), "--queue", str(queue), "--dry-run"])
+
+        monitor_state = temp / "monitor.md"
+        monitor_env = {
+            **os.environ,
+            "PROBE_CMD": "printf '42\\n'",
+            "THRESHOLD": "100",
+            "MAX_SAMPLES": "1",
+            "PROGRESS_FILE": str(monitor_state),
+        }
+        run(["bash", str(RUNNABLE / "threshold-monitor-loop.sh")], env=monitor_env)
+
+        detector_clean = temp / "detector-clean.py"
+        write(detector_clean, "raise SystemExit(0)\n")
+        state = temp / "docs-drift.jsonl"
+        run(
+            [
+                sys.executable,
+                str(DOCS_DRIFT),
+                "--discover-command",
+                shlex.join([sys.executable, str(detector_clean)]),
+                "--state",
+                str(state),
+            ]
+        )
+        receipt = json.loads(state.read_text(encoding="utf-8").splitlines()[-1])
+        if receipt["status"] != "no_drift":
+            raise RuntimeError("docs-drift no-work exit did not persist a no_drift receipt")
+
+        detector_drift = temp / "detector-drift.py"
+        write(detector_drift, "print('README output differs from current CLI help')\nraise SystemExit(1)\n")
+        dry_run = run(
+            [
+                sys.executable,
+                str(DOCS_DRIFT),
+                "--discover-command",
+                shlex.join([sys.executable, str(detector_drift)]),
+                "--dry-run",
+            ]
+        )
+        if json.loads(dry_run.stdout)["status"] != "drift_detected":
+            raise RuntimeError("docs-drift dry run did not expose confirmed evidence")
+
+        report_state = temp / "report-state.jsonl"
+        run(
+            [
+                sys.executable,
+                str(DOCS_DRIFT),
+                "--discover-command",
+                shlex.join([sys.executable, str(detector_drift)]),
+                "--report-only",
+                "--state",
+                str(report_state),
+            ],
+            expected=(2,),
+        )
+        report_receipt = json.loads(report_state.read_text(encoding="utf-8").splitlines()[-1])
+        if report_receipt["status"] != "reported":
+            raise RuntimeError("docs-drift report-only mode did not persist an escalation receipt")
+
+        repository = temp / "repo"
+        repository.mkdir()
+        write(repository / "README.md", "old command\n")
+        run(["git", "init", "-q"], cwd=repository)
+        run(["git", "add", "README.md"], cwd=repository)
+        run(
+            [
+                "git",
+                "-c",
+                "user.name=Loop Smoke Test",
+                "-c",
+                "user.email=loop-smoke@example.com",
+                "commit",
+                "-qm",
+                "fixture",
+            ],
+            cwd=repository,
+        )
+
+        agent = temp / "agent.py"
+        verifier = temp / "verifier.py"
+        write(agent, "from pathlib import Path\nPath('README.md').write_text('current command\\n', encoding='utf-8')\n")
+        write(
+            verifier,
+            "from pathlib import Path\nraise SystemExit(0 if Path('README.md').read_text(encoding='utf-8') == 'current command\\n' else 1)\n",
+        )
+        patch_state = temp / "patch-state.jsonl"
+        run(
+            [
+                sys.executable,
+                str(DOCS_DRIFT),
+                "--discover-command",
+                shlex.join([sys.executable, str(detector_drift)]),
+                "--agent-command",
+                shlex.join([sys.executable, str(agent)]),
+                "--verify-command",
+                shlex.join([sys.executable, str(verifier)]),
+                "--allowed-path",
+                "README.md",
+                "--workdir",
+                str(repository),
+                "--state",
+                str(patch_state),
+            ]
+        )
+        patch_receipt = json.loads(patch_state.read_text(encoding="utf-8").splitlines()[-1])
+        if patch_receipt["status"] != "verified" or patch_receipt["changed_paths"] != ["README.md"]:
+            raise RuntimeError("docs-drift patch mode did not persist a verified scoped change")
+
+        run(["git", "restore", "README.md"], cwd=repository)
+        unsafe_agent = temp / "unsafe-agent.py"
+        write(unsafe_agent, "from pathlib import Path\nPath('outside.txt').write_text('unsafe\\n')\nraise SystemExit(1)\n")
+        unsafe_state = temp / "unsafe-state.jsonl"
+        run(
+            [
+                sys.executable,
+                str(DOCS_DRIFT),
+                "--discover-command",
+                shlex.join([sys.executable, str(detector_drift)]),
+                "--agent-command",
+                shlex.join([sys.executable, str(unsafe_agent)]),
+                "--verify-command",
+                shlex.join([sys.executable, str(verifier)]),
+                "--allowed-path",
+                "README.md",
+                "--workdir",
+                str(repository),
+                "--state",
+                str(unsafe_state),
+            ],
+            expected=(2,),
+        )
+        unsafe_receipt = json.loads(unsafe_state.read_text(encoding="utf-8").splitlines()[-1])
+        if unsafe_receipt["status"] != "escalated" or "out-of-scope paths" not in unsafe_receipt["reason"]:
+            raise RuntimeError("docs-drift did not stop an out-of-scope edit from a failed agent command")
+
+    print("Runnable loop smoke checks passed.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/check_url_checker.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Regression checks for transient and permanent URL-checker failures."""
+
+from __future__ import annotations
+
+import io
+import urllib.error
+import urllib.request
+from unittest import mock
+
+from verify_urls import check_url
+
+
+class FakeResponse:
+    def __init__(self, url: str, status: int) -> None:
+        self.url = url
+        self.status = status
+
+    def geturl(self) -> str:
+        return self.url
+
+    def __enter__(self) -> "FakeResponse":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        return None
+
+
+class FixtureOpener:
+    def __init__(self) -> None:
+        self.transient_gets = 0
+
+    def open(self, request: urllib.request.Request, timeout: float) -> FakeResponse:
+        url = request.full_url
+        if request.get_method() == "HEAD":
+            raise urllib.error.HTTPError(url, 500, "fixture HEAD failure", {}, io.BytesIO())
+        if url.endswith("/transient"):
+            self.transient_gets += 1
+            if self.transient_gets == 1:
+                raise urllib.error.HTTPError(url, 500, "fixture transient failure", {}, io.BytesIO())
+            return FakeResponse(url, 200)
+        raise urllib.error.HTTPError(url, 404, "fixture missing", {}, io.BytesIO())
+
+
+def main() -> int:
+    opener = FixtureOpener()
+    with mock.patch("verify_urls.urllib.request.build_opener", return_value=opener), mock.patch(
+        "verify_urls.time.sleep"
+    ):
+        ok, detail = check_url("https://fixture.invalid/transient", timeout=2, attempts=2)
+        if not ok or detail != "200 GET" or opener.transient_gets != 2:
+            raise RuntimeError(f"transient 500 was not retried successfully: {ok=}, {detail=}")
+
+        ok, detail = check_url("https://fixture.invalid/missing", timeout=2, attempts=3)
+        if ok or detail != "404 GET":
+            raise RuntimeError(f"permanent 404 was not reported: {ok=}, {detail=}")
+
+    print("URL checker regression checks passed.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/verify_urls.py

@@ -21,6 +21,7 @@ from urllib.parse import urlparse
 
 URL_RE = re.compile(r'https?://[^\s)\]}>"]+')
 CLAUDE_DOC_HOSTS = {"code.claude.com", "docs.anthropic.com"}
+RETRYABLE_HTTP_CODES = {408, 425, 500, 502, 503, 504}
 
 
 class RedirectHandler(urllib.request.HTTPRedirectHandler):
@@ -81,7 +82,10 @@ def check_url(url: str, timeout: float, attempts: int) -> tuple[bool, str]:
                     return True, f"{error.code} restricted"
                 if method == "HEAD":
                     continue
-                return False, f"{error.code} {method}"
+                last_error = f"{error.code} {method}"
+                if error.code in RETRYABLE_HTTP_CODES:
+                    break
+                return False, last_error
             except Exception as error:  # noqa: BLE001 - report URL checker failures plainly.
                 last_error = error.__class__.__name__
                 if method == "HEAD":