feat(pipeline): report when a re-ingest disagrees with the page on disk (#104)

The asymmetry that makes unattended ingest safe (#103) also discarded a
real signal. When a fresh extraction produced a different version of a
section already on disk, the on-disk version won and the model's version
went in the bin without a word — so "the source is unchanged" and "the
source changed its mind and we ignored it" were indistinguishable.

wiki.MergeReport now returns the headings where the incoming version
disagreed and lost, and the ingest run reports them as warnings, which
AppendLog already writes into log.md.

This is the simplified answer to contradiction flagging at ingest. The
issue proposed calling brain-gardener's Judge from the ingest path, which
needs either a shared Go module across two repos or an HTTP service that
does not exist — and puts an LLM call on the write path, where a timeout
must neither fail the ingest nor silently mark nothing as contested.

None of that is necessary to get the signal. The merge already computes
the disagreement; it was throwing it away. Surfacing it costs nothing,
needs no model, no cue-word matcher, no cross-repo dependency, and is
deterministic.

Deliberately textual disagreement, not semantic contradiction. Deciding
whether a disagreement is a genuine contradiction stays with the
Judge-gated enrich pass that already runs hourly and is approval-gated by
design (brain-gardener#175). Detection here, adjudication there.

Merge is kept as a thin wrapper over MergeReport so existing callers are
untouched.

Refs #104, #103, brain-gardener#175, brain#21.

.context/system-prompt.txt

@@ -53,30 +53,14 @@ These rules apply to every task across every project, regardless of harness.
    logical change (one tool, one fix, one test) with passing tests. Main is always
    deployable. Never create long-lived feature branches.
 
-   **The PR trigger is RISK, not concurrency.** `risk/low` work commits straight to
+   **Exception — parallel agents on same repo:** If another agent is known to be
-   main with CI as the gate — that is most work and is unchanged. `risk/medium` and
+   actively working on the same repo simultaneously, create a short-lived branch
-   above opens a PR, even solo, even with nobody waiting to review it. This mirrors
+   (`agent/<description>`), finish the task, and merge to main within the same
-   the tiered merge model in `assessor-loop`
+   session. Do not leave agent branches open between sessions.
-   `method/transfer-to-a-regulated-organisation.md` §4.1, so the estate practises
-   what it sells instead of merging everything on green and claiming otherwise.
 
-   **Concurrency is NOT a reason to branch.** Measured 2026-08-29 across three real
+   **Exception — external contributor or client four-eyes requirement:** Use
-   collisions between parallel sessions: two were not branching problems at all — a
+   PR flow only when a human reviewer outside the project is required. Document
-   generated artifact written to the same path by both (branching turns that into a
+   the reason in PROJECT.md.
-   merge conflict on a 33k-line JSON), and uncommitted work in a shared checkout
-   (a per-session worktree fixes it) — and the third was an ordinary non-fast-forward
-   push resolved by rebase in seconds. Use a worktree per session on shared repos and
-   timestamp generated artifacts. Do not reach for a branch.
-
-   Branch+PR flow carries documented costs on solo repos: merging auto-closes gated
-   issues, review comments live on a thread separate from the issue's, and a
-   merged-and-deleted branch cannot be amended (brain:
-   `gitea-pr-merge-autoclose-and-review-comment-footguns`). Those are the price of
-   the `risk/medium`+ lane — paid deliberately, not incurred by accident.
-
-   **Exception — external contributor or client four-eyes requirement:** Use PR flow
-   when a human reviewer outside the project is required. Document the reason in
-   PROJECT.md.
 
 6. **Close the loop — every substantive task ends with the same ritual.** Shipping
    the code is not the end of the task; capturing it is. Run this unprompted:
@@ -94,18 +78,6 @@ These rules apply to every task across every project, regardless of harness.
    - Surface the brain entries and issue numbers in the closing summary so the
      trail is auditable.
 
-   **Chat is not a durable store. Never rely on Mathias remembering anything.**
-   Every gap, caveat, risk, open question and next step must land in one of four
-   places before the turn ends: **the brain**, **a repo** (code, docs, ADR),
-   **a tracker issue**, or **a plan file**. A finding stated only in conversation is
-   lost the moment the session closes — and this estate has repeatedly proved that a
-   remembered convention is an unreliable control.
-
-   This applies hardest to what is tempting to leave as a closing remark: "worth
-   knowing X isn't enforced yet", "this is a convention, not a gate", "we should
-   revisit Y". Those are exactly the items that need a locator. If it is worth
-   saying in a summary, it is worth writing where it can be found again without you.
-
 ## CAD sprint patterns
 
 Two CAD sprint archetypes (defs: brain `wiki/homelab/decisions/continuous-agentic-development-cad-concept-2026-06-16`):
@@ -176,10 +148,10 @@ Three machines on Tailscale:
 |---------|------|-----------|
 | koala | GPU inference, heavy compute | RTX 5070, runs k3s + llama-swap + shared postgres18/pgvector |
 | iguana | Services, builds | M2 Ultra Mac |
-| flamingo | Daily driver, edge | Apple Silicon Mac, ~/dev is here |
+| flamingo | Daily driver, edge | Mac mini, ~/dev is here |
 
 - **Model routing**: LiteLLM in front of llama-swap (local) + cloud APIs (when permitted)
-- **Orchestration**: k3s on koala only — single control-plane node, no workers (verified 2026-08-30). iguana and flamingo are on the tailnet but are not cluster members
+- **Orchestration**: k3s cluster across all three machines
 - **Networking**: Tailscale mesh
 
 ## Project landscape
@@ -275,11 +247,10 @@ When working on a project tagged with a client name:
 
 ## Harness-agnostic principles
 
-Supported harnesses (2026-09-01) — Cursor and Aider were dropped; do not
+This context is designed to work with any AI coding tool:
-re-add adapters for them:
+- Claude Code, Cursor, Aider, Open WebUI, Charmbracelet Mods/Crush
-- Claude Code, Antigravity, OpenCode, Mistral Vibe, Crush, Pi Coding Agent
+- Pi Coding Agent, Mistral Vibe, Antigravity
-- Open WebUI, Charmbracelet Mods, or any tool that takes a system prompt string
+- Any tool that accepts a system prompt or reads a markdown context file
-- Any other tool that reads `AGENTS.md`, which is the de facto convention
 
 The canonical source is always `.context/AGENT.md` (root) and `.context/PROJECT.md` (per-project).
 Derived files are committed (see *How context propagates* below) so a `git pull` on any host yields full agent context with no setup.
@@ -291,29 +262,15 @@ Canonical sources of truth:
 - Project: `<repo>/.context/PROJECT.md` (per-repo)
 
 Derived files (committed, regenerated by `task context:sync`):
-- `CLAUDE.md`, `AGENTS.md`, `.context/system-prompt.txt`
+- `CLAUDE.md`, `AGENTS.md`, `.cursorrules`, `.aider.conventions.md`,
-
+  `.context/system-prompt.txt`
-Repos still carrying `.cursorrules`, `.aider.conventions.md` or
-`.aider.conf.yml` are stale: nothing regenerates them. Delete them the next time
-you touch the repo, along with their entries in that repo's `task check`
-assertion.
 
 Workflow:
 1. Edit a canonical file. Run `task context:sync`. Commit canonical and
    derived together. Push.
-2. On any other host, `git pull` brings both. Which file a harness reads does
+2. On any other host, `git pull` brings both. Claude Code (tree-walking)
-   NOT split cleanly by lookup strategy, so do not reason from the strategy:
+   uses `CLAUDE.md`; Crush / Pi / Antigravity (cwd-only) use `AGENTS.md`;
-   - `CLAUDE.md` — Claude Code (walks up the tree)
+   Cursor uses `.cursorrules`; Aider uses `.aider.conventions.md`.
-   - `AGENTS.md` — Crush, Pi, Antigravity (cwd-only), OpenCode (project root,
-     global at `~/.config/opencode/AGENTS.md`), and Mistral Vibe, which **walks
-     up** from cwd and takes the first `AGENTS.md` it finds
-     (user-level `~/.vibe/AGENTS.md`)
-   - `.context/system-prompt.txt` — Open WebUI, Mods, raw API calls; not read by
-     any harness, it is for pasting
-
-   Vibe tree-walks for `AGENTS.md`, so "tree-walkers use CLAUDE.md" is false.
-   Each repo's `AGENTS.md` embeds the canonical and is the first one found from
-   inside that repo, so this works — but by construction, not by luck.
 3. `task check` runs `context:sync` then asserts `git status --porcelain`
    is empty over the derived files (catches both modified-tracked drift
    and missing-untracked adapters). A drift fails the check with a
@@ -324,20 +281,7 @@ unconditionally on every host, every harness.
 
 ## Engineering Skills
 
-Shared engineering skills live in the **`mathias/skills`** repo (`git.d-ma.be/mathias/skills`). Load at task start — not "on demand" but on schedule, before writing code. Browse `SKILLS_INDEX.md` for the full list.
+Shared engineering skills live in the **`mathias/skills`** repo (`git.d-ma.be/mathias/skills`). Clone it to `~/dev/skills/` and run `SKILLS_CHECKOUT_DIR="$PWD" bash install.sh` there to wire every skill into your harnesses (Claude Code, Crush, Antigravity, Mistral Vibe) as native, on-demand skills. (Use `install.sh`, not `task install` — the latter is currently broken, skills#7.) Load at task start — not "on demand" but on schedule, before writing code. Browse `~/dev/skills/SKILLS_INDEX.md` for the full list.
-
-**Claude Code** installs the repo as a plugin from the marketplace the same repo hosts. That path also carries the `secret-guard` and `pre-task-ritual` hooks and the brain/gitea/infra MCP servers, which symlinks cannot:
-
-```
-/plugin marketplace add https://git.d-ma.be/mathias/skills.git
-/plugin install skills@mathias
-```
-
-Skills are **namespaced** under Claude Code: load `tdd` as `skills:tdd`. The trigger table below uses bare names — prefix them.
-
-**Crush, Pi and OpenCode** have no plugin system and are wired by `install.sh` as one directory symlink per harness via `~/.agents/skills`. Do not clone the checkout into `~/dev`: that folder is iCloud-shared between the Macs and spans two path roots (`/Users/mathias` vs `/home/mathias` on koala), so a checkout there is a git working tree with two concurrent writers, and any absolute symlink stored in it is broken on one side by construction (skills#23). Leave `SKILLS_CHECKOUT_DIR` at its host-local default.
-
-Check a host with `task doctor` in the skills repo; it also runs automatically at session start via the plugin.
 
 **Skill trigger table — load before starting, not after getting stuck:**
 

.gitea/workflows/cd.yml

@@ -45,12 +45,6 @@ jobs:
           set -e
           trap 'rm -rf /tmp/infra-update; rm -f ~/.ssh/infra_deploy_key' EXIT
           IMAGE_TAG="${{ github.sha }}"
-          # infra#311: github.sha is never empty in practice, but the manifest
-          # patch below is the same shape that took Flux down estate-wide on
-          # 2026-08-25 -- an empty tag yields `image: <repo>:`, which is invalid
-          # YAML and fails the ENTIRE Kustomization, not just this app. The
-          # assert costs nothing and removes the class.
-          [ -n "${IMAGE_TAG:-}" ] || { echo "IMAGE_TAG is empty - refusing to patch"; exit 1; }
           mkdir -p ~/.ssh
           echo "${{ secrets.INFRA_DEPLOY_KEY }}" > ~/.ssh/infra_deploy_key
           chmod 600 ~/.ssh/infra_deploy_key

.githooks/pre-commit

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-# Pre-commit secret scan for the hyperguild repo.
-#
-# task check -> security:gitleaks enforces this in CI, but CI is after the
-# push. This catches a staged secret before it ever leaves the machine --
-# the infra#39 rotation pass found exactly this class of leak (a printed
-# credential, committed, archived into git) and there was no local gate to
-# have caught it. Mirrors infra's own .githooks/pre-commit (infra#326).
-#
-# Enable once per clone:   git config core.hooksPath .githooks
-# Bypass if absolutely needed: git commit --no-verify
-
-set -euo pipefail
-
-GITLEAKS="$(command -v gitleaks || true)"
-if [[ -z "$GITLEAKS" && -x "$(go env GOPATH 2>/dev/null)/bin/gitleaks" ]]; then
-  GITLEAKS="$(go env GOPATH)/bin/gitleaks"
-fi
-
-if [[ -z "$GITLEAKS" ]]; then
-  echo "⚠ gitleaks not installed — skipping local secret scan (CI still enforces it)."
-  echo "  Install: go install github.com/zricethezav/gitleaks/v8@latest"
-  exit 0
-fi
-
-echo "→ Scanning staged changes for secrets..."
-if ! "$GITLEAKS" protect --staged --redact --config .gitleaks.toml >/dev/null 2>&1; then
-  echo "  ✗ gitleaks found a secret in the staged changes."
-  echo "    Review with: gitleaks protect --staged --redact --config .gitleaks.toml -v"
-  echo "    If it is a false positive, allowlist it in .gitleaks.toml or add a"
-  echo "    '# gitleaks:allow' comment. Do NOT --no-verify a real secret."
-  exit 1
-fi
-echo "  ✓ no staged secrets"

.gitleaks.toml

@@ -56,16 +56,8 @@ paths = [
   '''ingestion/internal/claudewatcher/watcher_test\.go$''',
 ]
 
-# infra#344: the allowlist that used to sit here is gone, and so is the reason
+[[allowlists]]
-# for it. It suppressed docs/superpowers/plans/2026-04-22-phase4-attempt-wiring.md
+description = "Literal placeholder word REDACTED matched as if it were a token (verified 2026-08-04: extracted Secret == 'REDACTED' exactly, gitleaks' curl-auth-header rule matched the placeholder text itself, not a real credential)"
-# on the stated grounds that "extracted Secret == 'REDACTED' exactly ... the
+condition = "AND"
-# placeholder text itself, not a real credential" (verified 2026-08-04). That was
+paths = ['''docs/superpowers/plans/2026-04-22-phase4-attempt-wiring\.md$''']
-# not what the file contained: line 1054 carried a real 40-char hex Gitea PAT in
+regexes = ['''REDACTED''']
-# an `Authorization: token ...` header. Confirmed dead by side-effect — GET
-# /api/v1/user with it returns 401 — and redacted in that file, so there is now
-# nothing to allowlist.
-#
-# The `paths` entry also made the block far broader than its description: gitleaks
-# ORs global allowlist clauses and ignores `condition = "AND"`, so the whole file
-# was immune, not just lines matching /REDACTED/. A live token added to that doc
-# would have been suppressed on the strength of a note about a different value.

.gitleaksignore

@@ -1,33 +0,0 @@
-# Historical gitleaks findings, dispositioned (infra#326 / infra#317).
-#
-# WHY THIS FILE AND NOT .gitleaks.toml:
-# This is a finding in git HISTORY, surfaced by the full-history audit
-# (`task security:gitleaks:history`). The working-tree scan that gates commits
-# (`task security:gitleaks`, the pre-commit hook, CI) is clean. Suppressing by
-# PATH in .gitleaks.toml would also blind the working-tree scan for that file
-# forever; a fingerprint pins one finding in one commit, so a NEW secret in the
-# same file still fires.
-#
-# History is not rewritten here, so the remediation for a real leak is
-# ROTATION -- making the committed value worthless -- never scrubbing.
-#
-# Dispositioned 2026-08-29. Re-check with: task security:gitleaks:history
-
-# --- Real credential, ALREADY DEAD -------------------------------------------
-# A Gitea PAT pasted into a CD-watching command in a planning doc
-# (`Authorization: token <40-hex>`, last_eight 3105a670).
-#
-# Verified dead 2026-08-29: authenticating against
-# GET https://git.d-ma.be/api/v1/user with this exact value returns 401, so the
-# committed token no longer grants anything. It was almost certainly invalidated
-# by the early-August rotation of the `mathias` PATs (the same rotation whose
-# fan-out caused infra#260, where CI copies of the old value kept failing).
-#
-# No rotation action outstanding. Kept as a fingerprint rather than removed from
-# history because history cannot be rewritten here.
-#
-# The generalisable lesson is recorded separately: a credential printed into a
-# doc/transcript is permanent, so the only remedy is rotating it -- which in
-# this case had already happened for unrelated reasons, by luck rather than by
-# the leak being noticed.
-c9310b1079478bf4430b0a2dfb25445d7ccc9b59:docs/superpowers/plans/2026-04-22-phase4-attempt-wiring.md:curl-auth-header:1053

AGENTS.md

@@ -48,30 +48,14 @@ These rules apply to every task across every project, regardless of harness.
    logical change (one tool, one fix, one test) with passing tests. Main is always
    deployable. Never create long-lived feature branches.
 
-   **The PR trigger is RISK, not concurrency.** `risk/low` work commits straight to
+   **Exception — parallel agents on same repo:** If another agent is known to be
-   main with CI as the gate — that is most work and is unchanged. `risk/medium` and
+   actively working on the same repo simultaneously, create a short-lived branch
-   above opens a PR, even solo, even with nobody waiting to review it. This mirrors
+   (`agent/<description>`), finish the task, and merge to main within the same
-   the tiered merge model in `assessor-loop`
+   session. Do not leave agent branches open between sessions.
-   `method/transfer-to-a-regulated-organisation.md` §4.1, so the estate practises
-   what it sells instead of merging everything on green and claiming otherwise.
 
-   **Concurrency is NOT a reason to branch.** Measured 2026-08-29 across three real
+   **Exception — external contributor or client four-eyes requirement:** Use
-   collisions between parallel sessions: two were not branching problems at all — a
+   PR flow only when a human reviewer outside the project is required. Document
-   generated artifact written to the same path by both (branching turns that into a
+   the reason in PROJECT.md.
-   merge conflict on a 33k-line JSON), and uncommitted work in a shared checkout
-   (a per-session worktree fixes it) — and the third was an ordinary non-fast-forward
-   push resolved by rebase in seconds. Use a worktree per session on shared repos and
-   timestamp generated artifacts. Do not reach for a branch.
-
-   Branch+PR flow carries documented costs on solo repos: merging auto-closes gated
-   issues, review comments live on a thread separate from the issue's, and a
-   merged-and-deleted branch cannot be amended (brain:
-   `gitea-pr-merge-autoclose-and-review-comment-footguns`). Those are the price of
-   the `risk/medium`+ lane — paid deliberately, not incurred by accident.
-
-   **Exception — external contributor or client four-eyes requirement:** Use PR flow
-   when a human reviewer outside the project is required. Document the reason in
-   PROJECT.md.
 
 6. **Close the loop — every substantive task ends with the same ritual.** Shipping
    the code is not the end of the task; capturing it is. Run this unprompted:
@@ -89,18 +73,6 @@ These rules apply to every task across every project, regardless of harness.
    - Surface the brain entries and issue numbers in the closing summary so the
      trail is auditable.
 
-   **Chat is not a durable store. Never rely on Mathias remembering anything.**
-   Every gap, caveat, risk, open question and next step must land in one of four
-   places before the turn ends: **the brain**, **a repo** (code, docs, ADR),
-   **a tracker issue**, or **a plan file**. A finding stated only in conversation is
-   lost the moment the session closes — and this estate has repeatedly proved that a
-   remembered convention is an unreliable control.
-
-   This applies hardest to what is tempting to leave as a closing remark: "worth
-   knowing X isn't enforced yet", "this is a convention, not a gate", "we should
-   revisit Y". Those are exactly the items that need a locator. If it is worth
-   saying in a summary, it is worth writing where it can be found again without you.
-
 ## CAD sprint patterns
 
 Two CAD sprint archetypes (defs: brain `wiki/homelab/decisions/continuous-agentic-development-cad-concept-2026-06-16`):
@@ -171,10 +143,10 @@ Three machines on Tailscale:
 |---------|------|-----------|
 | koala | GPU inference, heavy compute | RTX 5070, runs k3s + llama-swap + shared postgres18/pgvector |
 | iguana | Services, builds | M2 Ultra Mac |
-| flamingo | Daily driver, edge | Apple Silicon Mac, ~/dev is here |
+| flamingo | Daily driver, edge | Mac mini, ~/dev is here |
 
 - **Model routing**: LiteLLM in front of llama-swap (local) + cloud APIs (when permitted)
-- **Orchestration**: k3s on koala only — single control-plane node, no workers (verified 2026-08-30). iguana and flamingo are on the tailnet but are not cluster members
+- **Orchestration**: k3s cluster across all three machines
 - **Networking**: Tailscale mesh
 
 ## Project landscape
@@ -270,11 +242,10 @@ When working on a project tagged with a client name:
 
 ## Harness-agnostic principles
 
-Supported harnesses (2026-09-01) — Cursor and Aider were dropped; do not
+This context is designed to work with any AI coding tool:
-re-add adapters for them:
+- Claude Code, Cursor, Aider, Open WebUI, Charmbracelet Mods/Crush
-- Claude Code, Antigravity, OpenCode, Mistral Vibe, Crush, Pi Coding Agent
+- Pi Coding Agent, Mistral Vibe, Antigravity
-- Open WebUI, Charmbracelet Mods, or any tool that takes a system prompt string
+- Any tool that accepts a system prompt or reads a markdown context file
-- Any other tool that reads `AGENTS.md`, which is the de facto convention
 
 The canonical source is always `.context/AGENT.md` (root) and `.context/PROJECT.md` (per-project).
 Derived files are committed (see *How context propagates* below) so a `git pull` on any host yields full agent context with no setup.
@@ -286,29 +257,15 @@ Canonical sources of truth:
 - Project: `<repo>/.context/PROJECT.md` (per-repo)
 
 Derived files (committed, regenerated by `task context:sync`):
-- `CLAUDE.md`, `AGENTS.md`, `.context/system-prompt.txt`
+- `CLAUDE.md`, `AGENTS.md`, `.cursorrules`, `.aider.conventions.md`,
-
+  `.context/system-prompt.txt`
-Repos still carrying `.cursorrules`, `.aider.conventions.md` or
-`.aider.conf.yml` are stale: nothing regenerates them. Delete them the next time
-you touch the repo, along with their entries in that repo's `task check`
-assertion.
 
 Workflow:
 1. Edit a canonical file. Run `task context:sync`. Commit canonical and
    derived together. Push.
-2. On any other host, `git pull` brings both. Which file a harness reads does
+2. On any other host, `git pull` brings both. Claude Code (tree-walking)
-   NOT split cleanly by lookup strategy, so do not reason from the strategy:
+   uses `CLAUDE.md`; Crush / Pi / Antigravity (cwd-only) use `AGENTS.md`;
-   - `CLAUDE.md` — Claude Code (walks up the tree)
+   Cursor uses `.cursorrules`; Aider uses `.aider.conventions.md`.
-   - `AGENTS.md` — Crush, Pi, Antigravity (cwd-only), OpenCode (project root,
-     global at `~/.config/opencode/AGENTS.md`), and Mistral Vibe, which **walks
-     up** from cwd and takes the first `AGENTS.md` it finds
-     (user-level `~/.vibe/AGENTS.md`)
-   - `.context/system-prompt.txt` — Open WebUI, Mods, raw API calls; not read by
-     any harness, it is for pasting
-
-   Vibe tree-walks for `AGENTS.md`, so "tree-walkers use CLAUDE.md" is false.
-   Each repo's `AGENTS.md` embeds the canonical and is the first one found from
-   inside that repo, so this works — but by construction, not by luck.
 3. `task check` runs `context:sync` then asserts `git status --porcelain`
    is empty over the derived files (catches both modified-tracked drift
    and missing-untracked adapters). A drift fails the check with a
@@ -319,20 +276,7 @@ unconditionally on every host, every harness.
 
 ## Engineering Skills
 
-Shared engineering skills live in the **`mathias/skills`** repo (`git.d-ma.be/mathias/skills`). Load at task start — not "on demand" but on schedule, before writing code. Browse `SKILLS_INDEX.md` for the full list.
+Shared engineering skills live in the **`mathias/skills`** repo (`git.d-ma.be/mathias/skills`). Clone it to `~/dev/skills/` and run `SKILLS_CHECKOUT_DIR="$PWD" bash install.sh` there to wire every skill into your harnesses (Claude Code, Crush, Antigravity, Mistral Vibe) as native, on-demand skills. (Use `install.sh`, not `task install` — the latter is currently broken, skills#7.) Load at task start — not "on demand" but on schedule, before writing code. Browse `~/dev/skills/SKILLS_INDEX.md` for the full list.
-
-**Claude Code** installs the repo as a plugin from the marketplace the same repo hosts. That path also carries the `secret-guard` and `pre-task-ritual` hooks and the brain/gitea/infra MCP servers, which symlinks cannot:
-
-```
-/plugin marketplace add https://git.d-ma.be/mathias/skills.git
-/plugin install skills@mathias
-```
-
-Skills are **namespaced** under Claude Code: load `tdd` as `skills:tdd`. The trigger table below uses bare names — prefix them.
-
-**Crush, Pi and OpenCode** have no plugin system and are wired by `install.sh` as one directory symlink per harness via `~/.agents/skills`. Do not clone the checkout into `~/dev`: that folder is iCloud-shared between the Macs and spans two path roots (`/Users/mathias` vs `/home/mathias` on koala), so a checkout there is a git working tree with two concurrent writers, and any absolute symlink stored in it is broken on one side by construction (skills#23). Leave `SKILLS_CHECKOUT_DIR` at its host-local default.
-
-Check a host with `task doctor` in the skills repo; it also runs automatically at session start via the plugin.
 
 **Skill trigger table — load before starting, not after getting stuck:**
 

README.md

@@ -76,6 +76,64 @@ that prompted the question is answered by naming it here instead.
 Full reasoning, including the reversal trigger: brain
 `wiki/hyperguild/decisions/brain-mcp-stays-in-ingestion-fix-discoverability-by-name`.
 
+## Ingest revises, it does not overwrite
+
+Re-ingesting a source **merges into the page already on disk** rather than
+replacing it. Previously the write was unconditional, so a second ingest of the
+same source discarded everything accumulated since — including hand-written
+sections.
+
+The merge is deliberately asymmetric in the existing page's favour:
+
+| On the page | In the fresh extraction | Result |
+|---|---|---|
+| a section | the same section | **the on-disk version wins** |
+| — | a new section | added |
+| a bullet list (`Sources`, `Key Claims`, …) | more bullets | unioned, no duplicates |
+| an append section (`Open Questions`, `Updates`, …) | more lines | only genuinely new lines appended |
+| frontmatter | frontmatter | **the on-disk frontmatter wins** |
+
+So an extraction can add to a note but never silently rewrite what a human put
+there, which is what makes it safe to run on every ingest rather than behind a
+review gate.
+
+Re-ingesting unchanged content is **byte-identical** — no diff, so brain-sync
+does not commit noise that hides real edits.
+
+Two fields are **generator-owned** and do get refreshed on a revise:
+`last_updated` and `source_hash`. Everything else on disk wins. The boundary is
+an explicit allowlist, so a field nobody has thought about stays human-owned.
+
+### Disagreement is reported, not resolved
+
+When the fresh extraction produces a *different version* of a section that
+already exists, the on-disk version still wins — but the run now says so:
+
+```
+wiki/sources/shape-up.md: source now disagrees on section "Summary" — on-disk version kept
+```
+
+That line lands in `log.md` with the rest of the run's warnings. Without it, "the
+source is unchanged" and "the source changed its mind and we ignored it" look
+identical from the outside.
+
+This is deliberately **textual** disagreement, not semantic contradiction: cheap,
+deterministic, no model on the write path. Deciding whether a disagreement is a
+genuine contradiction stays with the Judge-gated `brain-enrich` pass, which is
+approval-gated by design. Detection here, adjudication there.
+
+## Re-ingesting an unchanged source is skipped
+
+Ingest stores `source_hash` — sha256 of the ingested **body**, frontmatter
+excluded — on the source page. A later ingest of the same source compares it
+first and skips extraction entirely when it matches, reporting the skip rather
+than doing it silently.
+
+Body-only is deliberate: a re-crawl that stamps a new fetch date has not changed
+the source, and treating that as drift would re-extract the corpus every time a
+crawler ran. A missing or unreadable hash always means "extract" — a missed skip
+costs one extraction, a wrong skip loses an update.
+
 ## Phase 1 tools (available now)
 
 | Tool | What it does |

Taskfile.yml

@@ -86,26 +86,8 @@ tasks:
   check:
     desc: Run all checks (context freshness + lint + test + vet) across all modules
     cmds:
-      # Context sync is skipped under CI, matching dma-cli, gitea-mcp, and the
+      - task: context:sync
-      # rest of the estate. It is not a preference: context-sync.sh walks UP
-      # the tree for the canonical .context/AGENT.md, which lives in local-dev
-      # and does not exist on a CI runner. Without this guard, the script
-      # silently falls back to "project context only" and regenerates AGENTS.md
-      # and .context/system-prompt.txt shorter than their committed, correct
-      # versions -- so the drift assertion fails every CI run for a purely
-      # environmental reason, not real drift. Verified, not assumed: this is
-      # exactly what was happening here (AGENTS.md 430 lines committed vs. an
-      # 82-line regeneration on the runner).
-      #
-      # The cost is real and worth stating: drift is therefore only ever caught
-      # on a developer machine, or by infra's estate-wide context-sync-drift
-      # CronJob (ADR-0019), which does have canonical access and is the actual
-      # enforcement mechanism now.
       - cmd: |
-          if [ -n "${CI:-}" ]; then
-            echo "✓ context sync: skipped in CI (no canonical AGENT.md on the runner)"
-          else
-            bash scripts/context-sync.sh
           drift=$(git status --porcelain -- AGENTS.md CLAUDE.md .context/system-prompt.txt 2>/dev/null)
           if [ -n "$drift" ]; then
             echo "ERROR: derived adapters drifted from canonical context." >&2
@@ -116,7 +98,6 @@ tasks:
             exit 1
           fi
           echo "✓ context: canonical and adapters are in sync"
-          fi
       - task: lint
       - task: test
       - task: vet

docs/superpowers/plans/2026-04-22-phase4-attempt-wiring.md

@@ -1051,7 +1051,7 @@ git push
 ```bash
 # Poll until complete (replace RUN_ID with the new run):
 curl -s "https://gitea.d-ma.be/api/v1/repos/mathias/hyperguild/actions/runs?limit=2" \
-  -H "Authorization: token <REDACTED-dead-gitea-pat-infra#344>" \
+  -H "Authorization: token 736a8c36adcc6ecb41fff56e5ae4d0eb3105a670" \
   | python3 -c "import sys,json; [print(r['id'],r['status'],r.get('conclusion','—')) for r in json.load(sys.stdin)['workflow_runs']]"
 ```
 

ingestion/cmd/server/main.go

@@ -236,11 +236,6 @@ func main() {
 			fallbackModel := envOr("BRAIN_LLM_FALLBACK_MODEL", "gemma4:31b")
 			router.Fallback = llm.New(fallbackURL, "", fallbackModel, timeout)
 		}
-		if tertiaryURL := os.Getenv("BRAIN_LLM_TERTIARY_URL"); tertiaryURL != "" {
-			tertiaryModel := envOr("BRAIN_LLM_TERTIARY_MODEL", "gemini-2.5-flash")
-			tertiaryKey := os.Getenv("GEMINI_API_KEY")
-			router.Tertiary = llm.New(tertiaryURL, tertiaryKey, tertiaryModel, timeout)
-		}
 		answerComplete = router.Complete
 		logger.Info("brain answer LLM configured", "primary", primaryURL, "model", primaryModel)
 	}

ingestion/internal/llm/router.go

@@ -5,18 +5,14 @@ import (
 	"fmt"
 )
 
-// Router calls Primary first; on any error falls back to Fallback, then to
+// Router calls Primary first; on any error falls back to Fallback.
-// Tertiary. Fallback and Tertiary may each be nil — a nil tier is skipped and
+// Fallback may be nil, in which case primary errors are returned directly.
-// the chain returns the errors accumulated so far.
 type Router struct {
 	Primary  *Client
 	Fallback *Client
-	Tertiary *Client
 }
 
-// Complete implements pipeline.CompleteFunc, routing through Primary, then
+// Complete implements pipeline.CompleteFunc, routing through Primary then Fallback.
-// Fallback, then Tertiary — trying each configured tier in order and
-// returning the first success.
 func (r *Router) Complete(ctx context.Context, system, user string) (string, error) {
 	out, err := r.Primary.Complete(ctx, system, user)
 	if err == nil {
@@ -26,15 +22,8 @@ func (r *Router) Complete(ctx context.Context, system, user string) (string, err
 		return "", fmt.Errorf("primary llm: %w", err)
 	}
 	out, err2 := r.Fallback.Complete(ctx, system, user)
-	if err2 == nil {
+	if err2 != nil {
-		return out, nil
-	}
-	if r.Tertiary == nil {
 		return "", fmt.Errorf("primary llm: %w; fallback llm: %v", err, err2)
 	}
-	out, err3 := r.Tertiary.Complete(ctx, system, user)
-	if err3 != nil {
-		return "", fmt.Errorf("primary llm: %w; fallback llm: %v; tertiary llm: %v", err, err2, err3)
-	}
 	return out, nil
 }

ingestion/internal/llm/router_test.go

@@ -69,78 +69,3 @@ func TestRouter_NilFallback(t *testing.T) {
 	_, err := r.Complete(context.Background(), "sys", "user")
 	assert.Error(t, err)
 }
-
-func TestRouter_FallsBackToTertiaryWhenPrimaryAndFallbackFail(t *testing.T) {
-	fail := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		http.Error(w, "unavailable", http.StatusServiceUnavailable)
-	}))
-	defer fail.Close()
-	tertiary := mockServer(t, "from-tertiary")
-	defer tertiary.Close()
-
-	r := &Router{
-		Primary:  New(fail.URL, "", "m", time.Second),
-		Fallback: New(fail.URL, "", "m", time.Second),
-		Tertiary: New(tertiary.URL, "", "m", time.Second),
-	}
-	out, err := r.Complete(context.Background(), "sys", "user")
-	require.NoError(t, err)
-	assert.Equal(t, "from-tertiary", out)
-}
-
-func TestRouter_TertiaryNotCalledWhenFallbackSucceeds(t *testing.T) {
-	fail := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		http.Error(w, "unavailable", http.StatusServiceUnavailable)
-	}))
-	defer fail.Close()
-	fallback := mockServer(t, "from-fallback")
-	defer fallback.Close()
-	tertiary := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		t.Error("tertiary must not be called when fallback succeeds")
-	}))
-	defer tertiary.Close()
-
-	r := &Router{
-		Primary:  New(fail.URL, "", "m", time.Second),
-		Fallback: New(fallback.URL, "", "m", time.Second),
-		Tertiary: New(tertiary.URL, "", "m", time.Second),
-	}
-	out, err := r.Complete(context.Background(), "sys", "user")
-	require.NoError(t, err)
-	assert.Equal(t, "from-fallback", out)
-}
-
-func TestRouter_AllThreeFail(t *testing.T) {
-	fail := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		http.Error(w, "err", http.StatusBadGateway)
-	}))
-	defer fail.Close()
-
-	r := &Router{
-		Primary:  New(fail.URL, "", "m", time.Second),
-		Fallback: New(fail.URL, "", "m", time.Second),
-		Tertiary: New(fail.URL, "", "m", time.Second),
-	}
-	_, err := r.Complete(context.Background(), "sys", "user")
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "primary llm")
-	assert.Contains(t, err.Error(), "fallback llm")
-	assert.Contains(t, err.Error(), "tertiary llm")
-}
-
-func TestRouter_NilTertiary(t *testing.T) {
-	// Existing 2-tier deployments (no BRAIN_LLM_TERTIARY_URL) must keep working
-	// exactly as before — Tertiary is opt-in, not required.
-	fail := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		http.Error(w, "err", http.StatusBadGateway)
-	}))
-	defer fail.Close()
-
-	r := &Router{
-		Primary:  New(fail.URL, "", "m", time.Second),
-		Fallback: New(fail.URL, "", "m", time.Second),
-	}
-	_, err := r.Complete(context.Background(), "sys", "user")
-	assert.Error(t, err)
-	assert.NotContains(t, err.Error(), "tertiary")
-}

ingestion/internal/pipeline/build.go

@@ -76,6 +76,9 @@ func buildFrontmatter(rp RawPage, date string) string {
 		}
 		fmt.Fprintf(&sb, "date_ingested: %s\n", date)
 		fmt.Fprintf(&sb, "last_updated: %s\n", date)
+		if rp.SourceHash != "" {
+			fmt.Fprintf(&sb, "source_hash: %s\n", rp.SourceHash)
+		}
 		if rp.Source != "" {
 			fmt.Fprintf(&sb, "source: %s\n", yamlScalar(rp.Source))
 		}

ingestion/internal/pipeline/parse.go

@@ -20,6 +20,10 @@ type RawPage struct {
 	// ingested content's own frontmatter (see parseContentFrontmatter) — never
 	// set by the LLM. json:"-" keeps them immune to same-named keys the LLM
 	// might emit. Only meaningful for Type == "source".
+	// SourceHash is sha256 of the ingested BODY (frontmatter excluded), stamped
+	// so the next ingest of the same source can tell "unchanged" from "edited"
+	// without re-running extraction (#105).
+	SourceHash string `json:"-"`
 	Source     string `json:"-"`
 	Author     string `json:"-"`
 	Published  string `json:"-"`
@@ -112,6 +116,11 @@ type sourceMeta struct {
 	Source    string
 	Author    string
 	Published string
+	// BodyHash is sha256 of the content with any leading frontmatter removed.
+	// Body-only on purpose: a re-crawl that stamps a new fetch date has not
+	// changed the source, and treating that as drift would re-extract the
+	// whole corpus every time a crawler ran (#105).
+	BodyHash string
 }
 
 // parseContentFrontmatter extracts source/author/published from a leading
@@ -154,6 +163,7 @@ func applySourceMeta(pages []RawPage, meta sourceMeta) {
 		if pages[i].Type != "source" {
 			continue
 		}
+		pages[i].SourceHash = meta.BodyHash
 		pages[i].Source = meta.Source
 		pages[i].Author = meta.Author
 		pages[i].Published = meta.Published

ingestion/internal/pipeline/pipeline.go

@@ -3,6 +3,8 @@ package pipeline
 
 import (
 	"context"
+	"crypto/sha256"
+	"encoding/hex"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -26,6 +28,11 @@ type Config struct {
 type Result struct {
 	Pages    []string // relative paths written (or would-be written in dry-run)
 	Warnings []string
+	// Skipped reports that the source was byte-identical to the last ingest,
+	// so no extraction ran and nothing was written. Reported rather than
+	// silent: a run that does nothing must say so, or "the pipeline is fine"
+	// and "the pipeline stopped working" look the same (#105, #107).
+	Skipped bool
 }
 
 // Run ingests content and writes structured wiki pages to brainDir/wiki/.
@@ -43,6 +50,18 @@ func Run(ctx context.Context, cfg Config, brainDir, content, source string, dryR
 
 	sourceSlug := wiki.Slug(source)
 	date := time.Now().UTC().Format("2006-01-02")
+
+	// Drift check BEFORE any extraction: an unchanged source costs a full LLM
+	// pass over every chunk to produce a result that merges to nothing (#105).
+	// The merge is already idempotent (#103), so this is cost and signal, not
+	// correctness — which is why it is safe for it to be an early return.
+	bodyHash := hashBody(content)
+	if !dryRun && bodyHash != "" && bodyHash == storedSourceHash(brainDir, sourceSlug) {
+		return Result{Skipped: true, Warnings: []string{
+			fmt.Sprintf("source %q unchanged since last ingest (hash %s) — extraction skipped", source, bodyHash[:12]),
+		}}, nil
+	}
+
 	chunks := Chunk(content, cfg.ChunkSize)
 
 	var allRaw []RawPage
@@ -59,7 +78,9 @@ func Run(ctx context.Context, cfg Config, brainDir, content, source string, dryR
 		allWarnings = append(allWarnings, warnings...)
 	}
 
-	applySourceMeta(allRaw, parseContentFrontmatter(content))
+	meta := parseContentFrontmatter(content)
+	meta.BodyHash = bodyHash
+	applySourceMeta(allRaw, meta)
 
 	return buildAndWrite(allRaw, sourceSlug, date, brainDir, source, inventory, allWarnings, dryRun)
 }
@@ -96,7 +117,19 @@ func buildAndWrite(rawPages []RawPage, sourceSlug, date, brainDir, source string
 			if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
 				return Result{}, fmt.Errorf("mkdir for %s: %w", page.Path, err)
 			}
-			if err := os.WriteFile(dest, []byte(page.Content), 0o644); err != nil {
+			content, conflicts, err := reviseOrCreate(dest, page)
+			if err != nil {
+				return Result{}, err
+			}
+			for _, heading := range conflicts {
+				// Reported, not resolved. The on-disk version stands; whether
+				// the disagreement is a genuine contradiction is the
+				// Judge-gated enrich pass's call, not the write path's.
+				warnings = append(warnings, fmt.Sprintf(
+					"%s: source now disagrees on section %q — on-disk version kept",
+					page.Path, heading))
+			}
+			if err := os.WriteFile(dest, []byte(content), 0o644); err != nil {
 				return Result{}, fmt.Errorf("write %s: %w", page.Path, err)
 			}
 		}
@@ -115,6 +148,76 @@ func buildAndWrite(rawPages []RawPage, sourceSlug, date, brainDir, source string
 	return Result{Pages: written, Warnings: warnings}, nil
 }
 
+// hashBody returns sha256 of content with any leading frontmatter block
+// removed, or "" for empty content.
+//
+// Body-only on purpose: a re-crawl that stamps a new fetch date has not changed
+// the source, and treating that as drift would re-extract the corpus every time
+// a crawler ran (#105).
+func hashBody(content string) string {
+	body := content
+	if strings.HasPrefix(body, "---\n") {
+		if _, rest, found := strings.Cut(body[4:], "\n---"); found {
+			body = strings.TrimPrefix(rest, "\n")
+		}
+	}
+	if strings.TrimSpace(body) == "" {
+		return ""
+	}
+	sum := sha256.Sum256([]byte(body))
+	return hex.EncodeToString(sum[:])
+}
+
+// storedSourceHash reads source_hash from the source page a previous ingest
+// wrote, or "" when there is no such page or no such field.
+//
+// Absence always means "extract". That is the fail-safe direction: a missed
+// skip costs one extraction, while a wrong skip loses an update silently — and
+// silence is the failure mode this repo keeps paying for.
+func storedSourceHash(brainDir, sourceSlug string) string {
+	raw, err := os.ReadFile(filepath.Join(brainDir, "wiki", "sources", sourceSlug+".md"))
+	if err != nil {
+		return ""
+	}
+	for _, line := range strings.Split(string(raw), "\n") {
+		if key, value, found := strings.Cut(line, ":"); found && strings.TrimSpace(key) == "source_hash" {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}
+
+// reviseOrCreate returns the bytes to write for one extracted page: merged into
+// whatever is already on disk, or the page as-is when the path is new.
+//
+// This is the compile half of compile-on-ingest. Before it, the write was an
+// unconditional os.WriteFile, so re-ingesting a source replaced its page
+// wholesale and discarded everything accumulated since — including human edits
+// (hyperguild#43: "re-ingest overwrites wholesale").
+//
+// The merge is deliberately asymmetric in the existing page's favour:
+// wiki.Merge keeps the on-disk frontmatter and the on-disk version of any
+// section both sides carry, adds sections only the extraction produced, and
+// unions bullet lists. So a freshly extracted page can add to a note but never
+// silently rewrite what a human put there — which is what makes it safe to run
+// this on every ingest rather than behind a review gate.
+//
+// Known limitation: because the on-disk frontmatter wins, `last_updated` keeps
+// its first-ingest date on a revised page. Left deliberately — the alternative
+// is this function editing frontmatter it does not own, and no lint reads that
+// field today.
+func reviseOrCreate(dest string, page wiki.Page) (string, []string, error) {
+	existing, err := os.ReadFile(dest)
+	switch {
+	case os.IsNotExist(err):
+		return page.Content, nil, nil
+	case err != nil:
+		return "", nil, fmt.Errorf("read existing %s: %w", page.Path, err)
+	}
+	merged, conflicts := wiki.MergeReport(wiki.Page{Path: page.Path, Content: string(existing)}, page)
+	return merged.Content, conflicts, nil
+}
+
 // mergeAll deduplicates pages by path, merging content from later occurrences.
 func mergeAll(pages []wiki.Page) []wiki.Page {
 	order := make([]string, 0, len(pages))

ingestion/internal/pipeline/pipeline_test.go

@@ -8,6 +8,7 @@ import (
 	"net/http/httptest"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
@@ -171,3 +172,156 @@ func mustJSON(v any) string {
 	}
 	return string(b)
 }
+
+// --- B1: compile-on-ingest — revise the existing page, never clobber it -----
+
+func TestRunRaw_MergesIntoAnExistingPageInsteadOfOverwritingIt(t *testing.T) {
+	// Before this, buildAndWrite did an unconditional os.WriteFile: re-ingesting
+	// a source replaced its page wholesale, discarding anything accumulated
+	// since — including human edits. hyperguild#43 recorded the symptom as
+	// "re-ingest overwrites wholesale".
+	dir := t.TempDir()
+	page := filepath.Join(dir, "wiki", "sources", "shape-up.md")
+	require.NoError(t, os.MkdirAll(filepath.Dir(page), 0o755))
+	require.NoError(t, os.WriteFile(page, []byte(`---
+title: 'Shape Up'
+---
+
+## Summary
+
+A book about shaping product work.
+
+## My Take
+
+Read this before the next planning cycle.
+`), 0o644))
+
+	_, err := RunRaw(dir, "shape-up", []RawPage{{
+		Title: "Shape Up", Type: "source", Subtype: "book", Domain: "product-strategy",
+		Content: "## Summary\n\nA book about shaping product work.\n\n## Key Claims\n\n- Appetite beats estimation.\n",
+	}}, false)
+	require.NoError(t, err)
+
+	got, err := os.ReadFile(page)
+	require.NoError(t, err)
+	s := string(got)
+
+	assert.Contains(t, s, "## My Take", "a section the extraction never saw must survive the merge")
+	assert.Contains(t, s, "Read this before the next planning cycle.")
+	assert.Contains(t, s, "Appetite beats estimation.", "newly extracted material must still land")
+}
+
+func TestRunRaw_ReIngestingUnchangedContentIsByteIdentical(t *testing.T) {
+	// Compile-on-ingest runs on every ingest, so "nothing changed" must produce
+	// no diff at all. Otherwise every re-ingest dirties the tree, brain-sync
+	// commits it, and the git history fills with noise that hides real edits.
+	dir := t.TempDir()
+	raw := []RawPage{{
+		Title: "Shape Up", Type: "source", Subtype: "book", Domain: "product-strategy",
+		Content: "## Summary\n\nA book about shaping product work.\n\n## Open Questions\n\n- Does appetite scale?\n",
+	}}
+
+	_, err := RunRaw(dir, "shape-up", raw, false)
+	require.NoError(t, err)
+	first, err := os.ReadFile(filepath.Join(dir, "wiki", "sources", "shape-up.md"))
+	require.NoError(t, err)
+
+	_, err = RunRaw(dir, "shape-up", raw, false)
+	require.NoError(t, err)
+	second, err := os.ReadFile(filepath.Join(dir, "wiki", "sources", "shape-up.md"))
+	require.NoError(t, err)
+
+	assert.Equal(t, string(first), string(second),
+		"re-ingesting unchanged content must leave the page byte-identical")
+}
+
+// --- #105: source drift — an unchanged re-ingest must not re-extract --------
+
+func TestRun_SkipsExtractionWhenTheSourceIsUnchanged(t *testing.T) {
+	// #103 made a re-ingest harmless (byte-identical merge). It is still not
+	// free: the full LLM extraction runs over every chunk to produce a result
+	// that merges to nothing. This is the cost half.
+	dir := t.TempDir()
+	var calls int
+	cfg := Config{Complete: func(_ context.Context, _, _ string) (string, error) {
+		calls++
+		return `[{"title":"Shape Up","type":"source","subtype":"book","domain":"product","content":"## Summary\n\nA book.\n"}]`, nil
+	}}
+
+	content := "---\nsource: https://example.com/shape-up\n---\n\nThe body of the article.\n"
+
+	first, err := Run(context.Background(), cfg, dir, content, "shape-up", false)
+	require.NoError(t, err)
+	require.Equal(t, 1, calls, "first ingest must extract")
+	assert.False(t, first.Skipped)
+
+	second, err := Run(context.Background(), cfg, dir, content, "shape-up", false)
+	require.NoError(t, err)
+	assert.Equal(t, 1, calls, "unchanged content must not be extracted again")
+	assert.True(t, second.Skipped, "the skip must be reported, not silent")
+}
+
+func TestRun_ReExtractsWhenTheSourceBodyChanged(t *testing.T) {
+	dir := t.TempDir()
+	var calls int
+	cfg := Config{Complete: func(_ context.Context, _, _ string) (string, error) {
+		calls++
+		return `[{"title":"Shape Up","type":"source","subtype":"book","domain":"product","content":"## Summary\n\nA book.\n"}]`, nil
+	}}
+
+	_, err := Run(context.Background(), cfg, dir, "---\nsource: x\n---\n\nversion one\n", "shape-up", false)
+	require.NoError(t, err)
+	_, err = Run(context.Background(), cfg, dir, "---\nsource: x\n---\n\nversion two — the source was edited\n", "shape-up", false)
+	require.NoError(t, err)
+
+	assert.Equal(t, 2, calls, "changed content must be re-extracted")
+}
+
+func TestRun_FrontmatterOnlyChangeIsNotDrift(t *testing.T) {
+	// The hash covers the body, so re-fetching a page whose metadata moved
+	// (a re-crawl stamping a new date) is not treated as the source changing.
+	dir := t.TempDir()
+	var calls int
+	cfg := Config{Complete: func(_ context.Context, _, _ string) (string, error) {
+		calls++
+		return `[{"title":"Shape Up","type":"source","subtype":"book","domain":"product","content":"## Summary\n\nA book.\n"}]`, nil
+	}}
+
+	_, err := Run(context.Background(), cfg, dir, "---\nsource: x\nfetched: monday\n---\n\nsame body\n", "shape-up", false)
+	require.NoError(t, err)
+	_, err = Run(context.Background(), cfg, dir, "---\nsource: x\nfetched: tuesday\n---\n\nsame body\n", "shape-up", false)
+	require.NoError(t, err)
+
+	assert.Equal(t, 1, calls, "only the body counts as the source")
+}
+
+func TestRunRaw_ReportsWhenTheSourceDisagreesWithWhatIsOnDisk(t *testing.T) {
+	// The on-disk version still wins — that is what makes unattended ingest
+	// safe. But the run must say that the source now claims something else,
+	// or a changed source is indistinguishable from an unchanged one.
+	dir := t.TempDir()
+	page := filepath.Join(dir, "wiki", "sources", "shape-up.md")
+	require.NoError(t, os.MkdirAll(filepath.Dir(page), 0o755))
+	require.NoError(t, os.WriteFile(page, []byte(`---
+title: 'Shape Up'
+---
+
+## Summary
+
+Appetite is fixed, scope is variable.
+`), 0o644))
+
+	res, err := RunRaw(dir, "shape-up", []RawPage{{
+		Title: "Shape Up", Type: "source", Subtype: "book", Domain: "product",
+		Content: "## Summary\n\nAppetite is negotiable and scope is fixed.\n",
+	}}, false)
+	require.NoError(t, err)
+
+	got, err := os.ReadFile(page)
+	require.NoError(t, err)
+	assert.Contains(t, string(got), "Appetite is fixed", "on-disk version wins")
+
+	joined := strings.Join(res.Warnings, " ")
+	assert.Contains(t, joined, "Summary", "the disagreeing section must be named")
+	assert.Contains(t, joined, "shape-up", "and the page it happened on")
+}

ingestion/internal/wiki/merge.go

@@ -32,10 +32,33 @@ type section struct {
 // Frontmatter is taken from a. Sections are merged by strategy:
 // bullet sections union unique lines, append sections concatenate,
 // all others keep a's version. Sections in b not present in a are appended.
+// Merge combines two pages, discarding any disagreement silently.
+// Prefer MergeReport where the caller can act on the disagreement.
 func Merge(a, b Page) Page {
-	fmA, secsA := parseSections(a.Content)
+	page, _ := MergeReport(a, b)
-	_, secsB := parseSections(b.Content)
+	return page
+}
 
+// MergeReport is Merge, plus the headings of sections where b carried a
+// different version of a section a already had — and lost.
+//
+// That loss is the property which makes ingest safe to run unattended (#103):
+// a regenerating writer can add to a note but never rewrite it. But the
+// discarded text is also a signal, and until now it went in the bin: the source
+// now says something different about a section we already hold. Nobody could
+// tell "the source is unchanged" from "the source changed its mind and we
+// ignored it".
+//
+// Deliberately NOT a semantic contradiction check. This reports textual
+// disagreement, which is cheap, deterministic, and needs no model on the write
+// path. Deciding whether a disagreement is a genuine contradiction stays with
+// the Judge-gated enrich pass that already exists (brain-gardener#175), which
+// is approval-gated by design — detection here, adjudication there.
+func MergeReport(a, b Page) (Page, []string) {
+	fmA, secsA := parseSections(a.Content)
+	fmB, secsB := parseSections(b.Content)
+
+	var conflicts []string
 	idx := make(map[string]int, len(secsA))
 	for i, s := range secsA {
 		idx[s.heading] = i
@@ -53,11 +76,65 @@ func Merge(a, b Page) Page {
 		case bulletSections[sB.heading]:
 			secsA[i].content = mergeBullets(sA.content, sB.content)
 		case appendSections[sB.heading]:
-			secsA[i].content = strings.TrimRight(sA.content, "\n") + "\n\n" + strings.TrimLeft(sB.content, "\n")
+			secsA[i].content = appendNew(sA.content, sB.content)
+		default:
+			// a wins — but say that b disagreed, rather than dropping it mute.
+			if strings.TrimSpace(sA.content) != strings.TrimSpace(sB.content) {
+				conflicts = append(conflicts, sB.heading)
+			}
 		}
 	}
 
-	return Page{Path: a.Path, Content: rebuildContent(fmA, secsA)}
+	return Page{Path: a.Path, Content: rebuildContent(refreshOwned(fmA, fmB), secsA)}, conflicts
+}
+
+// generatorOwned names the frontmatter fields the ingest pipeline may refresh
+// on a page it is revising. Everything else on disk wins.
+//
+// #103 made the on-disk frontmatter win wholesale, which is what stops a
+// regenerating writer from overwriting human-set metadata — a title someone
+// fixed, or the claim-property envelope (brain#21). The cost was that fields
+// the generator legitimately owns froze at their first-ingest values: when it
+// last ran, and what it last saw.
+//
+// An explicit allowlist rather than a carve-out: the ownership boundary is
+// nameable, and a field nobody has thought about stays human-owned by default,
+// which is the safe direction.
+var generatorOwned = map[string]bool{
+	"last_updated": true,
+	"source_hash":  true,
+}
+
+// refreshOwned returns a's frontmatter with the generator-owned fields taken
+// from b where b supplies them. Fields absent from b keep a's value, so a
+// generator that stops emitting a field cannot blank it.
+func refreshOwned(a, b string) string {
+	bVals := make(map[string]string)
+	for _, line := range strings.Split(b, "\n") {
+		key, value, found := strings.Cut(line, ":")
+		if !found || !generatorOwned[strings.TrimSpace(key)] {
+			continue
+		}
+		bVals[strings.TrimSpace(key)] = strings.TrimSpace(value)
+	}
+	if len(bVals) == 0 {
+		return a
+	}
+
+	out := make([]string, 0, len(strings.Split(a, "\n")))
+	for _, line := range strings.Split(a, "\n") {
+		key, _, found := strings.Cut(line, ":")
+		k := strings.TrimSpace(key)
+		if found && generatorOwned[k] {
+			if v, ok := bVals[k]; ok {
+				out = append(out, k+": "+v)
+				delete(bVals, k)
+				continue
+			}
+		}
+		out = append(out, line)
+	}
+	return strings.Join(out, "\n")
 }
 
 func parseSections(markdown string) (frontmatter string, sections []section) {
@@ -96,15 +173,64 @@ func parseSections(markdown string) (frontmatter string, sections []section) {
 	return
 }
 
+// rebuildContent serialises sections back into a page.
+//
+// Each section body is normalised to exactly one trailing newline and no
+// leading blank line. Without that, a section keeps whatever blank lines it was
+// parsed with and this function adds its own, so every merge pass grows the page
+// by a blank line — invisible in a diff viewer, fatal to byte-stability. Compile-on-ingest
+// merges on every run, so "merging changes nothing when nothing changed" has to
+// hold at the byte level, not just the content level.
 func rebuildContent(frontmatter string, sections []section) string {
 	var sb strings.Builder
 	sb.WriteString(frontmatter)
 	for _, sec := range sections {
-		fmt.Fprintf(&sb, "\n## %s\n\n%s", sec.heading, sec.content)
+		body := strings.Trim(sec.content, "\n")
+		fmt.Fprintf(&sb, "\n## %s\n\n%s\n", sec.heading, body)
 	}
 	return sb.String()
 }
 
+// appendNew concatenates the lines of b that a does not already carry.
+//
+// Append sections used to concatenate wholesale, which is correct exactly once.
+// Compile-on-ingest merges a freshly extracted page into the one already on
+// disk, so an unchanged source re-ingested would grow "Open Questions" and
+// "Updates" on every run until the page is unreadable — and the drift guard
+// that would otherwise catch it (hashing the source body) does not exist yet,
+// so idempotency has to hold here rather than upstream.
+//
+// Line-level rather than block-level: the common case is a re-ingest carrying
+// one genuinely new line alongside several it already has. A block-level
+// "skip if identical" would duplicate the old lines every time that happened.
+//
+// The cost is that a line repeated verbatim on purpose collapses to one. For
+// these sections — questions, updates, evolving notes — a repeat is noise
+// rather than signal, and the failure is conservative: the page stops growing
+// instead of growing wrongly.
+func appendNew(a, b string) string {
+	seen := make(map[string]bool)
+	for _, line := range strings.Split(a, "\n") {
+		if t := strings.TrimSpace(line); t != "" {
+			seen[t] = true
+		}
+	}
+
+	var add []string
+	for _, line := range strings.Split(b, "\n") {
+		t := strings.TrimSpace(line)
+		if t == "" || seen[t] {
+			continue
+		}
+		seen[t] = true
+		add = append(add, line)
+	}
+	if len(add) == 0 {
+		return a // nothing new — leave the section byte-identical
+	}
+	return strings.TrimRight(a, "\n") + "\n\n" + strings.Join(add, "\n") + "\n"
+}
+
 func mergeBullets(a, b string) string {
 	seen := make(map[string]bool)
 	var lines []string

ingestion/internal/wiki/merge_test.go

@@ -53,3 +53,146 @@ func TestMerge_KeepsFrontmatterFromA(t *testing.T) {
 	assert.Contains(t, got.Content, "title: A")
 	assert.NotContains(t, got.Content, "title: B")
 }
+
+// --- brain#21/B1: merging must be safe to run again -------------------------
+
+func TestMerge_AppendSectionDoesNotDuplicateContentAlreadyPresent(t *testing.T) {
+	// Compile-on-ingest merges a freshly extracted page into the one already
+	// on disk. Bullet sections union, so they are naturally idempotent — but
+	// append sections concatenate, so re-ingesting an unchanged source would
+	// grow "Open Questions" on every run until the page is unreadable.
+	page := Page{Path: "wiki/sources/x.md", Content: `---
+title: X
+---
+
+## Open Questions
+
+- Does this converge?
+`}
+
+	once := Merge(page, page)
+	twice := Merge(once, page)
+
+	assert.Equal(t, 1, strings.Count(once.Content, "Does this converge?"),
+		"merging a page with itself must not duplicate an append section")
+	assert.Equal(t, once.Content, twice.Content,
+		"merge must be idempotent — a third pass may not keep growing the page")
+}
+
+func TestMerge_AppendSectionStillAccumulatesGenuinelyNewContent(t *testing.T) {
+	// The dedup must not turn append sections into keep-a-only sections:
+	// new material is exactly what compile-on-ingest exists to add.
+	existing := Page{Path: "wiki/sources/x.md", Content: `---
+title: X
+---
+
+## Open Questions
+
+- Does this converge?
+`}
+	fresh := Page{Path: "wiki/sources/x.md", Content: `---
+title: X
+---
+
+## Open Questions
+
+- What happens under load?
+`}
+
+	got := Merge(existing, fresh).Content
+	assert.Contains(t, got, "Does this converge?", "existing question must survive")
+	assert.Contains(t, got, "What happens under load?", "new question must be added")
+}
+
+func TestMerge_GeneratorOwnedFrontmatterFieldsAreRefreshed(t *testing.T) {
+	// #103 made on-disk frontmatter win wholesale, which is what protects
+	// human-set fields from a regenerating writer. The cost was that fields the
+	// generator legitimately owns — when it last ran, what it last saw — froze
+	// at their first-ingest values. An explicit owned-set is the boundary:
+	// named fields the generator may refresh, everything else human-owned.
+	existing := Page{Path: "wiki/sources/x.md", Content: `---
+title: 'X'
+last_updated: 2026-01-01
+source_hash: aaaa
+half_life: durable
+claim_provenance: asserted
+---
+
+## Summary
+
+Original.
+`}
+	fresh := Page{Path: "wiki/sources/x.md", Content: `---
+title: 'Renamed by the model'
+last_updated: 2026-08-22
+source_hash: bbbb
+---
+
+## Summary
+
+Rewritten by the model.
+`}
+
+	got := Merge(existing, fresh).Content
+
+	assert.Contains(t, got, "last_updated: 2026-08-22", "generator owns last_updated")
+	assert.Contains(t, got, "source_hash: bbbb", "generator owns source_hash")
+	assert.Contains(t, got, "title: 'X'", "a human-set title must survive regeneration")
+	assert.Contains(t, got, "half_life: durable", "the claim envelope must survive regeneration")
+	assert.Contains(t, got, "claim_provenance: asserted")
+	assert.Contains(t, got, "Original.", "an existing section still wins over the model's rewrite")
+	assert.NotContains(t, got, "Renamed by the model")
+}
+
+func TestMerge_ReportsSectionsWhereTheFreshVersionWasDiscarded(t *testing.T) {
+	// The asymmetry that makes ingest safe (on-disk wins) also throws away a
+	// real signal: the source now says something different about a section we
+	// already have. Today that disagreement is silently discarded, so nobody
+	// can tell "the source is unchanged" from "the source changed its mind and
+	// we ignored it".
+	existing := Page{Path: "wiki/sources/x.md", Content: `---
+title: 'X'
+---
+
+## Summary
+
+Appetite is fixed, scope is variable.
+
+## Method
+
+Six-week cycles.
+`}
+	fresh := Page{Path: "wiki/sources/x.md", Content: `---
+title: 'X'
+---
+
+## Summary
+
+Appetite is negotiable and scope is fixed.
+
+## Method
+
+Six-week cycles.
+`}
+
+	got, conflicts := MergeReport(existing, fresh)
+
+	assert.Contains(t, got.Content, "Appetite is fixed", "on-disk version still wins")
+	assert.NotContains(t, got.Content, "negotiable")
+	assert.Equal(t, []string{"Summary"}, conflicts,
+		"only the section that actually disagreed is reported")
+}
+
+func TestMerge_ReportsNothingWhenTheFreshVersionAgrees(t *testing.T) {
+	page := Page{Path: "wiki/sources/x.md", Content: `---
+title: 'X'
+---
+
+## Summary
+
+Appetite is fixed, scope is variable.
+`}
+
+	_, conflicts := MergeReport(page, page)
+	assert.Empty(t, conflicts, "identical content is not a disagreement")
+}

scripts/context-sync.sh

@@ -5,29 +5,15 @@
 # For Claude Code: generates project-only CLAUDE.md (it inherits root via tree walk)
 # For everything else: concatenates root AGENT.md + project PROJECT.md
 #
-# Cursor and Aider adapters removed 2026-09-01 — neither is a supported harness
+# Usage: ./scripts/context-sync.sh [adapter...]
-# any more. Supported: Claude Code, Antigravity, OpenCode, Mistral Vibe, Crush,
-# Pi. All read CLAUDE.md or AGENTS.md; system-prompt.txt remains for Open WebUI,
-# Mods and raw API use.
-#
-# Usage: ./scripts/context-sync.sh [--force] [adapter...]
 # Task:  task context:sync
 #
 # Override root context: ROOT_CONTEXT=~/dev/.context/AGENT.md ./scripts/context-sync.sh
 
 set -euo pipefail
 
-# Parse --force flag and collect adapter names separately
-FORCE=false
-ADAPTERS=()
-for _arg in "$@"; do
-  case "$_arg" in
-    --force) FORCE=true ;;
-    *) ADAPTERS+=("$_arg") ;;
-  esac
-done
-
 PROJECT_FILE=".context/PROJECT.md"
+SKILLS_DIR=".skills"
 
 # Walk up to find root .context/AGENT.md
 find_root_context() {
@@ -50,28 +36,19 @@ if [ ! -f "$PROJECT_FILE" ]; then
   exit 1
 fi
 
-# Pre-flight: reject unfilled {{...}} placeholders unless --force
-if [ "$FORCE" = false ]; then
-  _placeholders=$(grep -n '{{[^}]*}}' "$PROJECT_FILE" 2>/dev/null || true)
-  if [ -n "$_placeholders" ]; then
-    echo "Error: unfilled placeholders in $PROJECT_FILE:" >&2
-    while IFS= read -r _match; do
-      _lineno="${_match%%:*}"
-      _content="${_match#*:}"
-      _token=$(printf '%s' "$_content" | grep -o '{{[^}]*}}' | head -1)
-      echo "  $PROJECT_FILE:$_lineno: unfilled placeholder $_token" >&2
-    done <<< "$_placeholders"
-    echo "" >&2
-    echo "Fill these placeholders, then re-run: task context:sync" >&2
-    echo "To bypass validation: bash scripts/context-sync.sh --force" >&2
-    exit 1
-  fi
-fi
-
 if [ -n "$ROOT_CONTEXT" ] && [ -f "$ROOT_CONTEXT" ]; then
   echo "  Root context: $ROOT_CONTEXT"
 else
-  echo "  No root AGENT.md found (project context only)"
+  # No reachable root AGENT.md — common in CI's clean checkout. The root+project
+  # adapters (AGENTS.md, system-prompt.txt) require the root context to
+  # regenerate correctly, so we skip them entirely and only regenerate CLAUDE.md
+  # (which is project-only and inherits root via tree walk in Claude Code itself).
+  echo "  No root AGENT.md found — regenerating CLAUDE.md only"
+  echo "Syncing project context from $PROJECT_FILE..."
+  cat "$PROJECT_FILE" > CLAUDE.md
+  echo "  → CLAUDE.md (project-only)"
+  echo "Done."
+  exit 0
 fi
 
 # Emit root context + separator
@@ -118,7 +95,6 @@ generate_system_prompt() {
 
 # ── MCP config ───────────────────────────────────────────────
 generate_mcp() {
-  # Ensure baseline file exists with project-specific knowledge server
   if [ ! -f .context/mcp.json ]; then
     cat > .context/mcp.json << 'JSON'
 {
@@ -130,47 +106,27 @@ generate_mcp() {
   }
 }
 JSON
+    echo "  → .context/mcp.json (new)"
+  else
+    echo "  → .context/mcp.json (exists, skipped)"
   fi
-
-  # Merge root mcp-servers.json if found alongside root AGENT.md
-  local root_mcp=""
-  if [ -n "$ROOT_CONTEXT" ] && [ -f "$ROOT_CONTEXT" ]; then
-    local candidate
-    candidate="$(dirname "$ROOT_CONTEXT")/mcp-servers.json"
-    [ -f "$candidate" ] && root_mcp="$candidate"
-  fi
-
-  if [ -z "$root_mcp" ]; then
-    echo "  → .context/mcp.json (exists, no root mcp-servers.json found)"
-    return
-  fi
-
-  # Root servers take precedence over project entries on key conflict
-  local root_servers count updated
-  root_servers=$(jq '.servers' "$root_mcp")
-  count=$(printf '%s' "$root_servers" | jq 'keys | length')
-  updated=$(jq --argjson root "$root_servers" \
-    '.mcpServers = (.mcpServers + $root)' \
-    .context/mcp.json)
-  printf '%s\n' "$updated" > .context/mcp.json
-  echo "  → .context/mcp.json (merged $count root servers)"
 }
 
 echo "Syncing project context from $PROJECT_FILE..."
 
-if [ ${#ADAPTERS[@]} -eq 0 ]; then
+if [ $# -eq 0 ]; then
   generate_claude
   generate_agents
   generate_system_prompt
   generate_mcp
 else
-  for adapter in "${ADAPTERS[@]}"; do
+  for adapter in "$@"; do
     case "$adapter" in
       claude)  generate_claude ;;
       agents)  generate_agents ;;
       prompt|system|openwebui|owui|generic) generate_system_prompt ;;
       mcp)     generate_mcp ;;
-      *) echo "Unknown adapter: $adapter" >&2; exit 1 ;;
+      *) echo "Unknown adapter: $adapter" ;;
     esac
   done
 fi