Add GitHub PR feedback module and fix attribution for mirrored PRs

github_feedback.py posts pipeline status to GitHub PRs at three touchpoints:
discovery ack, eval review result, and merge/close outcome. Only fires for
PRs with a github_pr link (set by sync-mirror.sh). All calls non-fatal.

contributor.py: expanded git author fallback to scan all non-merge commits
(was only checking last commit), added teleo-bot and github-actions[bot]
to bot filter list.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

deploy/sync-mirror.sh

@@ -47,6 +47,37 @@ fi
 log "Fetching from GitHub..."
 git fetch origin --prune >> "$LOG" 2>&1 || log "WARN: GitHub fetch failed"
 
+# Step 2.1: Fetch GitHub fork PR refs
+# Fork-based PRs don't create branches on origin — they create refs/pull/N/head
+# Fetch these so we can push them to Forgejo for evaluation
+GITHUB_PAT_STEP2=$(cat "$GITHUB_PAT_FILE" 2>/dev/null | tr -d '[:space:]')
+if [ -n "$GITHUB_PAT_STEP2" ]; then
+    OPEN_PRS=$(curl -sf "https://api.github.com/repos/$GITHUB_REPO/pulls?state=open&per_page=100" \
+        -H "Authorization: token $GITHUB_PAT_STEP2" 2>/dev/null || echo "[]")
+    echo "$OPEN_PRS" | python3 -c "
+import sys, json
+prs = json.load(sys.stdin)
+for pr in prs:
+    head = pr.get('head', {})
+    # Only process fork PRs (repo differs from base repo)
+    base_repo = pr.get('base', {}).get('repo', {}).get('full_name', '')
+    head_repo = head.get('repo', {}) or {}
+    head_full = head_repo.get('full_name', '')
+    if head_full and head_full != base_repo:
+        print(f\"{pr['number']} {head.get('ref', '')} {head.get('sha', '')}\")
+" 2>/dev/null | while read pr_num branch_name head_sha; do
+        if [ -z "$pr_num" ] || [ -z "$branch_name" ]; then continue; fi
+        PR_BRANCH="gh-pr-${pr_num}/${branch_name}"
+        # Check if we already have this ref at the right SHA
+        EXISTING=$(git rev-parse "refs/heads/$PR_BRANCH" 2>/dev/null || true)
+        if [ "$EXISTING" = "$head_sha" ]; then continue; fi
+        # Fetch the PR ref and create a local branch
+        git fetch origin "refs/pull/${pr_num}/head:refs/heads/$PR_BRANCH" >> "$LOG" 2>&1 && \
+            log "Fetched fork PR #$pr_num -> $PR_BRANCH" || \
+            log "WARN: Failed to fetch fork PR #$pr_num"
+    done
+fi
+
 # Step 2.5: GitHub main -> Forgejo main (ff-only)
 # If a PR was merged on GitHub, GitHub main is ahead of Forgejo main.
 # Fast-forward Forgejo main to match — safe because ff-only guarantees no divergence.
@@ -108,10 +139,18 @@ if [ -n "$GITHUB_ONLY" ]; then
     FORGEJO_TOKEN=$(cat /opt/teleo-eval/secrets/forgejo-admin-token 2>/dev/null)
     for branch in $GITHUB_ONLY; do
         log "New from GitHub: $branch -> Forgejo"
-        git push forgejo "refs/remotes/origin/$branch:refs/heads/$branch" >> "$LOG" 2>&1 || {
-            log "WARN: Failed to push $branch to Forgejo"
-            continue
-        }
+        # Fork PR branches live as local refs (from Step 2.1), not on origin remote
+        if [[ "$branch" == gh-pr-* ]]; then
+            git push forgejo "refs/heads/$branch:refs/heads/$branch" >> "$LOG" 2>&1 || {
+                log "WARN: Failed to push fork PR branch $branch to Forgejo"
+                continue
+            }
+        else
+            git push forgejo "refs/remotes/origin/$branch:refs/heads/$branch" >> "$LOG" 2>&1 || {
+                log "WARN: Failed to push $branch to Forgejo"
+                continue
+            }
+        fi
         # Auto-create PR on Forgejo for mirrored branches (external contributor path)
         # Skip pipeline-internal branches
         case "$branch" in
@@ -141,7 +180,17 @@ for line in sys.stdin:
 print('no')
 " "$branch" 2>/dev/null || echo "no")
             if [ "$HAS_PR" = "no" ]; then
-                PR_TITLE=$(echo "$branch" | sed 's|/|: |;s/-/ /g')
+                # Build PR title — for fork PRs, use the GitHub PR title
+                if [[ "$branch" == gh-pr-* ]]; then
+                    FORK_GH_NUM=$(echo "$branch" | sed 's|gh-pr-\([0-9]*\)/.*|\1|')
+                    GITHUB_PAT_T=$(cat "$GITHUB_PAT_FILE" 2>/dev/null | tr -d '[:space:]')
+                    PR_TITLE=$(curl -sf "https://api.github.com/repos/$GITHUB_REPO/pulls/$FORK_GH_NUM" \
+                        -H "Authorization: token $GITHUB_PAT_T" 2>/dev/null | \
+                        python3 -c "import sys,json; print(json.load(sys.stdin).get('title',''))" 2>/dev/null || true)
+                    [ -z "$PR_TITLE" ] && PR_TITLE=$(echo "$branch" | sed 's|/|: |;s/-/ /g')
+                else
+                    PR_TITLE=$(echo "$branch" | sed 's|/|: |;s/-/ /g')
+                fi
                 RESULT=$(curl -sf -X POST "http://localhost:3000/api/v1/repos/teleo/teleo-codex/pulls" \
                     -H "Authorization: token $FORGEJO_TOKEN" \
                     -H "Content-Type: application/json" \
@@ -150,17 +199,22 @@ print('no')
                 if [ -n "$PR_NUM" ]; then
                     log "Auto-created PR #$PR_NUM on Forgejo for $branch"
                     # Step 4.5: Link GitHub PR to Forgejo PR in pipeline DB
-                    GITHUB_PAT=$(cat "$GITHUB_PAT_FILE" 2>/dev/null | tr -d '[:space:]')
-                    if [ -n "$GITHUB_PAT" ]; then
-                        GH_PR_NUM=$(curl -sf "https://api.github.com/repos/$GITHUB_REPO/pulls?head=living-ip:$branch&state=all" \
-                            -H "Authorization: token $GITHUB_PAT" 2>/dev/null | \
-                            python3 -c "import sys,json; prs=json.load(sys.stdin); print(prs[0]['number'] if prs else '')" 2>/dev/null || true)
-                        if [ -n "$GH_PR_NUM" ]; then
-                            sqlite3 "$PIPELINE_DB" "UPDATE prs SET github_pr = $GH_PR_NUM WHERE number = $PR_NUM;" 2>/dev/null && \
-                                log "Linked GitHub PR #$GH_PR_NUM -> Forgejo PR #$PR_NUM" || \
-                                log "WARN: Failed to link GitHub PR #$GH_PR_NUM to Forgejo PR #$PR_NUM in DB"
+                    if [[ "$branch" == gh-pr-* ]]; then
+                        GH_PR_NUM=$(echo "$branch" | sed 's|gh-pr-\([0-9]*\)/.*|\1|')
+                    else
+                        GITHUB_PAT=$(cat "$GITHUB_PAT_FILE" 2>/dev/null | tr -d '[:space:]')
+                        GH_PR_NUM=""
+                        if [ -n "$GITHUB_PAT" ]; then
+                            GH_PR_NUM=$(curl -sf "https://api.github.com/repos/$GITHUB_REPO/pulls?head=living-ip:$branch&state=all" \
+                                -H "Authorization: token $GITHUB_PAT" 2>/dev/null | \
+                                python3 -c "import sys,json; prs=json.load(sys.stdin); print(prs[0]['number'] if prs else '')" 2>/dev/null || true)
                         fi
                     fi
+                    if [ -n "$GH_PR_NUM" ]; then
+                        sqlite3 "$PIPELINE_DB" "UPDATE prs SET github_pr = $GH_PR_NUM WHERE number = $PR_NUM;" 2>/dev/null && \
+                            log "Linked GitHub PR #$GH_PR_NUM -> Forgejo PR #$PR_NUM" || \
+                            log "WARN: Failed to link GitHub PR #$GH_PR_NUM to Forgejo PR #$PR_NUM in DB"
+                    fi
                 else
                     log "WARN: Failed to auto-create PR for $branch"
                 fi

lib/contributor.py

@@ -153,11 +153,27 @@ async def record_contributor_attribution(conn, pr_number: int, branch: str, git_
             agent_id = agent_id_match.group(1).strip() if agent_id_match else None
             upsert_contributor(conn, handle, agent_id, current_role, today)
 
-    # Fallback: if no attribution block found, credit the branch agent as extractor
+    # Fallback: if no Pentagon-Agent trailer found, try git commit authors
+    _BOT_AUTHORS = frozenset({
+        "m3taversal", "teleo", "teleo-bot", "pipeline",
+        "github-actions[bot]", "forgejo-actions",
+    })
     if not agents_found:
-        row = conn.execute("SELECT agent FROM prs WHERE number = ?", (pr_number,)).fetchone()
-        if row and row["agent"]:
-            upsert_contributor(conn, row["agent"].lower(), None, "extractor", today)
+        rc_author, author_output = await git_fn(
+            "log", f"origin/main..origin/{branch}", "--no-merges",
+            "--format=%an", timeout=10,
+        )
+        if rc_author == 0 and author_output.strip():
+            for author_line in author_output.strip().split("\n"):
+                author_name = author_line.strip().lower()
+                if author_name and author_name not in _BOT_AUTHORS:
+                    upsert_contributor(conn, author_name, None, "extractor", today)
+                    agents_found.add(author_name)
+
+        if not agents_found:
+            row = conn.execute("SELECT agent FROM prs WHERE number = ?", (pr_number,)).fetchone()
+            if row and row["agent"] and row["agent"] != "external":
+                upsert_contributor(conn, row["agent"].lower(), None, "extractor", today)
 
 
 def upsert_contributor(

lib/db.py

@@ -208,6 +208,7 @@ BRANCH_PREFIX_MAP = {
     "leo": ("leo", "entity"),
     "reweave": ("pipeline", "reweave"),
     "fix": ("pipeline", "fix"),
+    "contrib": ("external", "contrib"),
 }
 
 
@@ -217,6 +218,9 @@ def classify_branch(branch: str) -> tuple[str, str]:
     Returns ('unknown', 'unknown') and logs a warning for unrecognized prefixes.
     """
     prefix = branch.split("/", 1)[0] if "/" in branch else branch
+    # Fork PR branches: gh-pr-N/original-branch
+    if prefix.startswith("gh-pr-"):
+        return ("external", "contrib")
     result = BRANCH_PREFIX_MAP.get(prefix)
     if result is None:
         logger.warning("Unknown branch prefix %r in branch %r — defaulting to ('unknown', 'unknown')", prefix, branch)

lib/eval_actions.py

@@ -18,6 +18,7 @@ from . import config, db
 from .eval_parse import classify_issues
 from .feedback import format_rejection_comment
 from .forgejo import api as forgejo_api, get_agent_token, repo_path
+from .github_feedback import on_closed, on_eval_complete
 from .pr_state import close_pr
 
 logger = logging.getLogger("pipeline.eval_actions")
@@ -81,6 +82,11 @@ async def terminate_pr(conn, pr_number: int, reason: str):
         logger.warning("PR #%d: Forgejo close failed — skipping source requeue, will retry next cycle", pr_number)
         return
 
+    try:
+        await on_closed(conn, pr_number, reason=reason)
+    except Exception:
+        logger.exception("PR #%d: GitHub close feedback failed (non-fatal)", pr_number)
+
     # Tag source for re-extraction with feedback
     cursor = conn.execute(
         """UPDATE sources SET status = 'needs_reextraction',

lib/evaluate.py

@@ -41,6 +41,7 @@ from .forgejo import get_agent_token, get_pr_diff, repo_path
 from .merge import PIPELINE_OWNED_PREFIXES
 from .llm import run_batch_domain_review, run_domain_review, run_leo_review, triage_pr
 from .eval_actions import dispose_rejected_pr, post_formal_approvals, terminate_pr
+from .github_feedback import on_eval_complete
 from .pr_state import approve_pr, close_pr, reopen_pr, start_review
 from .validate import load_existing_claims
 
@@ -267,6 +268,12 @@ async def evaluate_pr(conn, pr_number: int, tier: str = None) -> dict:
         # Disposition: check if this PR should be terminated or kept open
         await dispose_rejected_pr(conn, pr_number, eval_attempts, domain_issues)
 
+        try:
+            await on_eval_complete(conn, pr_number, outcome="rejected",
+                                   review_text=domain_review, issues=domain_issues)
+        except Exception:
+            logger.exception("PR #%d: GitHub eval feedback failed (non-fatal)", pr_number)
+
         if domain_verdict != "skipped":
             pr_cost += costs.record_usage(
                 conn, config.EVAL_DOMAIN_MODEL, "eval_domain",
@@ -358,6 +365,12 @@ async def evaluate_pr(conn, pr_number: int, tier: str = None) -> dict:
             logger.info("PR #%d: APPROVED + auto_merge (agent branch %s)", pr_number, branch_name)
         else:
             logger.info("PR #%d: APPROVED (tier=%s, leo=%s, domain=%s)", pr_number, tier, leo_verdict, domain_verdict)
+
+        try:
+            await on_eval_complete(conn, pr_number, outcome="approved",
+                                   review_text=leo_review or domain_review)
+        except Exception:
+            logger.exception("PR #%d: GitHub eval feedback failed (non-fatal)", pr_number)
     else:
         # Collect all issue tags from both reviews
         all_issues = []
@@ -398,6 +411,12 @@ async def evaluate_pr(conn, pr_number: int, tier: str = None) -> dict:
         # Disposition: check if this PR should be terminated or kept open
         await dispose_rejected_pr(conn, pr_number, eval_attempts, all_issues)
 
+        try:
+            await on_eval_complete(conn, pr_number, outcome="rejected",
+                                   review_text=leo_review or domain_review, issues=all_issues)
+        except Exception:
+            logger.exception("PR #%d: GitHub eval feedback failed (non-fatal)", pr_number)
+
     # Record cost (only for reviews that actually ran)
     if domain_verdict != "skipped":
         pr_cost += costs.record_usage(

lib/github_feedback.py

@@ -0,0 +1,185 @@
+"""GitHub PR feedback — posts pipeline status to GitHub PRs for external contributors.
+
+Three touchpoints:
+1. Discovery ack: when pipeline discovers a mirrored PR
+2. Eval review: when evaluation completes (approved or rejected with reasoning)
+3. Merge/close outcome: when PR is merged or permanently closed
+
+Only fires for PRs with a github_pr link (set by sync-mirror.sh).
+All calls are non-fatal — GitHub feedback never blocks the pipeline.
+"""
+
+import logging
+import os
+
+import aiohttp
+
+from . import config
+
+logger = logging.getLogger("pipeline.github_feedback")
+
+GITHUB_API = "https://api.github.com"
+GITHUB_REPO = "living-ip/teleo-codex"
+
+_BOT_ACCOUNTS = frozenset({"m3taversal", "teleo-bot", "teleo", "github-actions[bot]"})
+
+
+def _github_pat() -> str | None:
+    pat_file = config.SECRETS_DIR / "github-pat"
+    if pat_file.exists():
+        return pat_file.read_text().strip()
+    return os.environ.get("GITHUB_PAT")
+
+
+async def _post_comment(github_pr: int, body: str) -> bool:
+    pat = _github_pat()
+    if not pat:
+        logger.warning("No GitHub PAT — skipping feedback for GH PR #%d", github_pr)
+        return False
+
+    url = f"{GITHUB_API}/repos/{GITHUB_REPO}/issues/{github_pr}/comments"
+    headers = {
+        "Authorization": f"Bearer {pat}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                url, headers=headers, json={"body": body},
+                timeout=aiohttp.ClientTimeout(total=30),
+            ) as resp:
+                if resp.status >= 400:
+                    text = await resp.text()
+                    logger.error("GitHub comment on PR #%d failed: %d %s", github_pr, resp.status, text[:200])
+                    return False
+                logger.info("GitHub comment posted on PR #%d", github_pr)
+                return True
+    except Exception:
+        logger.exception("GitHub comment on PR #%d failed", github_pr)
+        return False
+
+
+async def _close_github_pr(github_pr: int) -> bool:
+    pat = _github_pat()
+    if not pat:
+        return False
+
+    url = f"{GITHUB_API}/repos/{GITHUB_REPO}/pulls/{github_pr}"
+    headers = {
+        "Authorization": f"Bearer {pat}",
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.patch(
+                url, headers=headers, json={"state": "closed"},
+                timeout=aiohttp.ClientTimeout(total=30),
+            ) as resp:
+                if resp.status >= 400:
+                    text = await resp.text()
+                    logger.error("GitHub close PR #%d failed: %d %s", github_pr, resp.status, text[:200])
+                    return False
+                logger.info("GitHub PR #%d closed", github_pr)
+                return True
+    except Exception:
+        logger.exception("GitHub close PR #%d failed", github_pr)
+        return False
+
+
+def _get_github_pr(conn, forgejo_pr: int) -> int | None:
+    row = conn.execute(
+        "SELECT github_pr FROM prs WHERE number = ? AND github_pr IS NOT NULL",
+        (forgejo_pr,),
+    ).fetchone()
+    return row["github_pr"] if row else None
+
+
+async def on_discovery(conn, forgejo_pr: int):
+    """Post discovery acknowledgment to GitHub PR."""
+    gh_pr = _get_github_pr(conn, forgejo_pr)
+    if not gh_pr:
+        return
+
+    body = (
+        "Your contribution has been received by the Teleo evaluation pipeline. "
+        "It's queued for automated review (priority: high).\n\n"
+        "You'll receive updates here as it progresses through evaluation.\n\n"
+        "_Automated message from the [LivingIP](https://livingip.xyz) pipeline._"
+    )
+    await _post_comment(gh_pr, body)
+
+
+async def on_eval_complete(conn, forgejo_pr: int, *, outcome: str, review_text: str = None, issues: list[str] = None):
+    """Post evaluation result to GitHub PR.
+
+    outcome: 'approved', 'rejected', 'changes_requested'
+    """
+    gh_pr = _get_github_pr(conn, forgejo_pr)
+    if not gh_pr:
+        return
+
+    if outcome == "approved":
+        body = "**Evaluation: Approved**\n\nYour contribution passed automated review and is queued for merge."
+        if review_text:
+            body += f"\n\n<details>\n<summary>Review details</summary>\n\n{review_text[:3000]}\n\n</details>"
+    elif outcome == "rejected":
+        body = "**Evaluation: Changes Requested**\n\n"
+        if issues:
+            body += "Issues found:\n"
+            for issue in issues:
+                body += f"- {issue}\n"
+        if review_text:
+            body += f"\n<details>\n<summary>Full review</summary>\n\n{review_text[:3000]}\n\n</details>"
+        body += (
+            "\n\nThe pipeline will attempt automated fixes where possible. "
+            "If fixes fail, the PR will be closed — you're welcome to resubmit."
+        )
+    else:
+        body = f"**Evaluation: {outcome}**\n\n"
+        if review_text:
+            body += review_text[:3000]
+
+    body += "\n\n_Automated message from the [LivingIP](https://livingip.xyz) pipeline._"
+    await _post_comment(gh_pr, body)
+
+
+async def on_merged(conn, forgejo_pr: int, *, claims_count: int = None):
+    """Post merge confirmation and close GitHub PR."""
+    gh_pr = _get_github_pr(conn, forgejo_pr)
+    if not gh_pr:
+        return
+
+    body = "**Merged!** Your contribution has been merged into the knowledge base."
+    if claims_count and claims_count > 0:
+        body += f" ({claims_count} claim{'s' if claims_count != 1 else ''} added)"
+    body += (
+        "\n\nThank you for contributing to LivingIP. "
+        "Your attribution has been recorded.\n\n"
+        "_Automated message from the [LivingIP](https://livingip.xyz) pipeline._"
+    )
+    await _post_comment(gh_pr, body)
+    await _close_github_pr(gh_pr)
+
+
+async def on_closed(conn, forgejo_pr: int, *, reason: str = None):
+    """Post closure notification and close GitHub PR."""
+    gh_pr = _get_github_pr(conn, forgejo_pr)
+    if not gh_pr:
+        return
+
+    body = "**Closed.** "
+    if reason:
+        body += reason
+    else:
+        body += "This PR was closed after evaluation."
+    body += (
+        "\n\nYou're welcome to resubmit with changes. "
+        "See the evaluation feedback above for guidance.\n\n"
+        "_Automated message from the [LivingIP](https://livingip.xyz) pipeline._"
+    )
+    await _post_comment(gh_pr, body)
+    await _close_github_pr(gh_pr)

lib/merge.py

@@ -46,6 +46,7 @@ for _prefix in PIPELINE_OWNED_PREFIXES:
 from .cascade import cascade_after_merge
 from .cross_domain import cross_domain_after_merge
 from .forgejo import get_agent_token, get_pr_diff, repo_path
+from .github_feedback import on_discovery, on_merged, on_closed
 
 logger = logging.getLogger("pipeline.merge")
 
@@ -146,6 +147,12 @@ async def discover_external_prs(conn) -> int:
                 if origin == "human":
                     await _post_ack_comment(pr["number"])
 
+                # GitHub PR feedback for mirrored PRs
+                try:
+                    await on_discovery(conn, pr["number"])
+                except Exception:
+                    logger.exception("PR #%d: GitHub discovery feedback failed (non-fatal)", pr["number"])
+
                 discovered += 1
 
         if len(prs) < 50:
@@ -860,6 +867,12 @@ async def _merge_domain_queue(conn, domain: str) -> tuple[int, int]:
             except Exception:
                 logger.exception("PR #%d: cross_domain failed (non-fatal)", pr_num)
 
+            # GitHub PR feedback: notify contributor of merge
+            try:
+                await on_merged(conn, pr_num)
+            except Exception:
+                logger.exception("PR #%d: GitHub merge feedback failed (non-fatal)", pr_num)
+
             conn.commit()  # Commit DB writes before slow branch deletion
 
             # Delete remote branch immediately (Ganymede Q4)

tests/test_contributor.py

@@ -200,7 +200,8 @@ def test_record_fallback_to_pr_agent():
 
     async def run():
         with patch("lib.contributor.get_pr_diff", new_callable=AsyncMock, return_value=mock_diff):
-            git_fn = AsyncMock(return_value=(0, "no trailers here"))
+            # First call: trailer log (no trailers), Second call: author log (bot name → skipped)
+            git_fn = AsyncMock(side_effect=[(0, "no trailers here"), (0, "m3taversal")])
             with patch("lib.contributor.config") as mock_config:
                 mock_config.CONTRIBUTOR_TIER_RULES = {
                     "veteran": {"claims_merged": 50, "min_days_since_first": 90, "challenges_survived": 5},
@@ -213,6 +214,29 @@ def test_record_fallback_to_pr_agent():
     assert row is not None
     assert row["extractor_count"] == 1
 
+
+def test_record_fallback_to_git_author():
+    """External contributors get credited via git commit author."""
+    conn = _make_attribution_db()
+    conn.execute("INSERT INTO prs VALUES (200, 'contrib', 'external')")
+    mock_diff = "+++ b/domains/ai-alignment/claim.md\n+new content\n"
+
+    async def run():
+        with patch("lib.contributor.get_pr_diff", new_callable=AsyncMock, return_value=mock_diff):
+            # First call: trailer log (no trailers), Second call: author log (external name)
+            git_fn = AsyncMock(side_effect=[(0, "no trailers"), (0, "Cameron-S1")])
+            with patch("lib.contributor.config") as mock_config:
+                mock_config.CONTRIBUTOR_TIER_RULES = {
+                    "veteran": {"claims_merged": 50, "min_days_since_first": 90, "challenges_survived": 5},
+                    "contributor": {"claims_merged": 10},
+                }
+                await record_contributor_attribution(conn, 200, "contrib/cameron/challenge", git_fn)
+
+    asyncio.run(run())
+    row = conn.execute("SELECT * FROM contributors WHERE handle = 'cameron-s1'").fetchone()
+    assert row is not None
+    assert row["extractor_count"] == 1
+
 def test_record_parses_pentagon_trailer():
     conn = _make_attribution_db()
     mock_diff = "+++ b/domains/crypto/claim.md\n+new file content\n"