fix(brain): a one-word tunnel title must match the prose case-exactly

AutoTunnel matched note titles case-insensitively, so a one-word title linked
every entry that happened to use that word. Measured on the live corpus: 185
entries carry an auto-written See-also link to wiki/telos/decisions/wrong.md
(title "WRONG") and 136 to .../status.md — the two most-linked nodes in the
whole graph, and both of them artifacts of the English language rather than
references. telos's projects/problems/strategies/goals/beliefs entries account
for another ~60 between them.

That pollution is not cosmetic: inbound-link count is what the duplicate
Fixer picks survivors by, what orphan detection reads, and what brain_graph
shows.

One-word titles now need the title's own casing in the prose ("WRONG", "BERT",
"NLP" — an entity name in a sentence still links). Multi-word titles keep the
case-insensitive match: "risk tier middleware" is a real mention however it is
capitalised, and a three-word collision is not an accident.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.context/mcp.json

@@ -7,6 +7,29 @@
     "supervisor": {
       "url": "http://localhost:3200/mcp",
       "description": "Hyperguild SDO — skill workers (tdd, retrospective), brain tools (brain_query, brain_write), session logging, tier detection"
+    },
+    "brain": {
+      "type": "http",
+      "url": "https://koala.tail30472e.ts.net:8443/mcp",
+      "headers": {
+        "Authorization": "Bearer ${BRAIN_MCP_TOKEN}"
+      }
+    },
+    "gitea": {
+      "_comment": "gitea-mcp authenticates by PASS-THROUGH: the bearer is a Gitea PAT it validates against Gitea and then acts as. GITEA_MCP_TOKEN -- which this entry used until 2026-09-08 -- 401s against it, so every harness synced from this file had a dead gitea server and no signal saying so. Probed 2026-09-08: GITEA_MCP_TOKEN 401, DMABE_GITEA_API_TOKEN 200, on both the public and the Serve URL.",
+      "type": "http",
+      "url": "https://koala.tail30472e.ts.net:8446/mcp",
+      "headers": {
+        "Authorization": "Bearer ${DMABE_GITEA_API_TOKEN}"
+      }
+    },
+    "infra": {
+      "_comment": "The bearer is belt-and-braces: this endpoint answers 200 with or without it, since Serve already limits reach to the tailnet. Sending it anyway means the day the server starts enforcing is not the day every harness breaks.",
+      "type": "http",
+      "url": "https://koala.tail30472e.ts.net:8444/mcp",
+      "headers": {
+        "Authorization": "Bearer ${INFRA_MCP_TOKEN}"
+      }
     }
   }
 }

ingestion/cmd/server/main.go

@@ -396,6 +396,29 @@ func main() {
 		}
 		host := envOr("CLAUDE_INGEST_HOST", systemHostname())
 		interval := time.Duration(envInt("CLAUDE_INGEST_INTERVAL", 60)) * time.Second
+
+		// Project directories excluded from ingestion entirely, as globs
+		// against the project directory name — e.g.
+		// "*cobalt-dingo*,*claude-worktrees-bridge-cse*".
+		//
+		// This is a veto list, deliberately named as one. It complements the
+		// client-name scrubber rather than replacing it: the scrubber drops
+		// individual TURNS whose content matches, while this never opens a
+		// project's files at all. Sessions working on live company financials
+		// are excluded here because their content is confidential in ways no
+		// pattern reliably recognises, and their learnings are captured
+		// deliberately through the session-close ritual instead.
+		//
+		// Caveat worth knowing: a project directory is derived from the
+		// session's WORKING DIRECTORY, not from the repositories it touches.
+		// A session run from ~/dev that happens to read a skipped repo will
+		// NOT be excluded by this. The scrubber remains the control for
+		// content; this is a control for whole workspaces.
+		skipProjects := splitList(os.Getenv("CLAUDE_INGEST_SKIP_PROJECTS"))
+		if len(skipProjects) > 0 {
+			logger.Info("claudewatcher: projects excluded from ingestion", "patterns", skipProjects)
+		}
+
 		sink := &claudeSink{brainDir: brainDir, logger: logger}
 		go func() {
 			if err := claudewatcher.Watch(ctx, claudewatcher.Config{
@@ -405,6 +428,7 @@ func main() {
 				Sink:         sink,
 				Cursors:      cursorStore,
 				Logger:       logger,
+				SkipProjects: skipProjects,
 			}); err != nil && err != context.Canceled {
 				logger.Error("claudewatcher exited", "err", err)
 			}

ingestion/internal/api/handler.go

@@ -133,6 +133,16 @@ func WriteNote(brainDir string, opts WriteNoteOptions) (string, error) {
 		return "", fmt.Errorf("content is required")
 	}
 
+	// In the primitive, not in a caller: POST /write reaches here directly,
+	// without the BrainStore, and a gate one door wide is not a gate.
+	// BrainStore still calls the strip itself to report Ref.Unlinked; the
+	// second pass is a no-op on already-clean content.
+	clean, _, err := brain.StripUnresolvedLinks(brainDir, opts.Content)
+	if err != nil {
+		return "", err
+	}
+	opts.Content = clean
+
 	if opts.Wing != "" && opts.Hall != "" {
 		return writeHallNote(brainDir, opts)
 	}

ingestion/internal/api/handler_test.go

@@ -497,3 +497,45 @@ func TestWriteNote_RejectsClaimFieldWithoutProvenance(t *testing.T) {
 	_, statErr := os.Stat(filepath.Join(dir, "wiki/homelab/facts/no-provenance.md"))
 	assert.True(t, os.IsNotExist(statErr))
 }
+
+// The HTTP POST /write door reaches WriteNote directly, without the
+// BrainStore, so the unresolved-wikilink strip has to live in the primitive
+// or that door stays ungated.
+func TestWriteNote_UnwrapsUnresolvedWikilinks(t *testing.T) {
+	dir := t.TempDir()
+	_, err := api.WriteNote(dir, api.WriteNoteOptions{
+		Content: "# Target\n\nbody\n", Filename: "target", Wing: "a", Hall: "facts",
+	})
+	require.NoError(t, err)
+
+	rel, err := api.WriteNote(dir, api.WriteNoteOptions{
+		Content:  "See [[target]] and [[gitea-ci]].\n",
+		Filename: "src", Wing: "a", Hall: "facts",
+	})
+	require.NoError(t, err)
+
+	got, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(rel)))
+	require.NoError(t, err)
+	assert.Contains(t, string(got), "[[target]]")
+	assert.Contains(t, string(got), "and gitea-ci.")
+	assert.NotContains(t, string(got), "[[gitea-ci]]")
+}
+
+func TestUpdateNote_UnwrapsUnresolvedWikilinks(t *testing.T) {
+	dir := t.TempDir()
+	_, err := api.WriteNote(dir, api.WriteNoteOptions{
+		Content: "old\n", Filename: "n", Wing: "a", Hall: "facts",
+	})
+	require.NoError(t, err)
+
+	rel, _, _, err := api.UpdateNote(dir, api.UpdateNoteOptions{
+		Wing: "a", Hall: "facts", Slug: "n",
+		Content: "Related: [[secret-hygiene]].\n", Reason: "r",
+	})
+	require.NoError(t, err)
+
+	got, err := os.ReadFile(filepath.Join(dir, filepath.FromSlash(rel)))
+	require.NoError(t, err)
+	assert.Contains(t, string(got), "Related: secret-hygiene.")
+	assert.NotContains(t, string(got), "[[secret-hygiene]]")
+}

ingestion/internal/api/update.go

@@ -64,6 +64,14 @@ func UpdateNote(brainDir string, opts UpdateNoteOptions) (relPath, contentHash,
 		return "", "", "", fmt.Errorf("content is required")
 	}
 
+	// Same reason as WriteNote: the strip belongs in the primitive so every
+	// door inherits it.
+	clean, _, err := brain.StripUnresolvedLinks(brainDir, opts.Content)
+	if err != nil {
+		return "", "", "", err
+	}
+	opts.Content = clean
+
 	var rel string
 	if opts.Path != "" {
 		rel = opts.Path

ingestion/internal/brain/linkcheck.go

@@ -0,0 +1,157 @@
+package brain
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// wikilinkRE matches [[target]] and [[target|Display Text]].
+var wikilinkRE = regexp.MustCompile(`\[\[([^\]|]+)(?:\|([^\]]*))?\]\]`)
+
+// fencedCodeRE and inlineCodeRE mark the regions where a [[...]] is a
+// syntax example rather than a link. Same exclusion brain-gardener's audit
+// applies on the read side, so the write gate and the audit agree on what
+// counts as a link at all.
+var (
+	fencedCodeRE = regexp.MustCompile("(?s)```.*?```")
+	inlineCodeRE = regexp.MustCompile("`[^`\n]*`")
+)
+
+// StripUnresolvedLinks unwraps every [[wikilink]] in content whose target
+// resolves to no entry under knowledge/ or wiki/, leaving the link's display
+// text (or its target) as plain prose. It returns the rewritten content and
+// the sorted, de-duplicated targets it unwrapped.
+//
+// WHY UNWRAP RATHER THAN REJECT THE WRITE
+// Agents write [[...]] around anything that feels related — a skill name, a
+// repo, an agent-local memory file — and none of those are brain entries.
+// Every one of those becomes a permanent [high] broken-link finding that no
+// deterministic Fixer can repair, because there is no target to repoint to:
+// the brain-audit digest grew from 19 to 63 high findings between 2026-08-26
+// and 2026-09-16, and 53 of the 63 were exactly this. Rejecting the write
+// instead would push the failure onto claudewatcher's unattended ingest path,
+// where a refused write is a lost learning. Unwrapping keeps the author's
+// words, keeps the write, and keeps the graph honest.
+//
+// An empty corpus (no knowledge/ or wiki/ yet, or a misconfigured brainDir)
+// returns content unchanged: nothing resolving is a bootstrap state, not
+// evidence that every target was invented.
+func StripUnresolvedLinks(brainDir, content string) (string, []string, error) {
+	index, err := entryIndex(brainDir)
+	if err != nil {
+		return "", nil, err
+	}
+	if len(index) == 0 {
+		return content, nil, nil
+	}
+
+	code := codeSpans(content)
+	stripped := map[string]struct{}{}
+
+	var b strings.Builder
+	last := 0
+	for _, m := range wikilinkRE.FindAllStringSubmatchIndex(content, -1) {
+		start, end := m[0], m[1]
+		if overlaps(start, end, code) {
+			continue
+		}
+		target := strings.TrimSpace(content[m[2]:m[3]])
+		if _, ok := index[linkKey(target)]; ok {
+			continue
+		}
+		display := target
+		if m[4] >= 0 {
+			if d := strings.TrimSpace(content[m[4]:m[5]]); d != "" {
+				display = d
+			}
+		}
+		b.WriteString(content[last:start])
+		b.WriteString(display)
+		last = end
+		stripped[target] = struct{}{}
+	}
+	if last == 0 {
+		return content, nil, nil
+	}
+	b.WriteString(content[last:])
+
+	targets := make([]string, 0, len(stripped))
+	for t := range stripped {
+		targets = append(targets, t)
+	}
+	sort.Strings(targets)
+	return b.String(), targets, nil
+}
+
+// linkedTrees are the two trees that hold linkable entries — the same pair
+// package notes admits under ScopeNotes. Duplicated rather than imported
+// because that list is unexported there and this is a read-only mirror.
+var linkedTrees = []string{"knowledge", "wiki"}
+
+// entryIndex maps every form a wikilink may name an entry by — its bare slug
+// and its path form (wiki/<wing>/<hall>/<slug>.md -> wing/hall/slug) — to a
+// present marker. Mirrors brain-gardener's resolver so an accepted link is
+// one the audit will also resolve.
+func entryIndex(brainDir string) (map[string]struct{}, error) {
+	index := map[string]struct{}{}
+	for _, dir := range linkedTrees {
+		root := filepath.Join(brainDir, dir)
+		if _, err := os.Stat(root); os.IsNotExist(err) {
+			continue
+		} else if err != nil {
+			return nil, fmt.Errorf("stat %s: %w", dir, err)
+		}
+		err := filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if d.IsDir() || !strings.HasSuffix(path, ".md") {
+				return nil
+			}
+			rel, err := filepath.Rel(brainDir, path)
+			if err != nil {
+				return err
+			}
+			rel = filepath.ToSlash(rel)
+			index[strings.TrimSuffix(filepath.Base(rel), ".md")] = struct{}{}
+			index[strings.TrimPrefix(strings.TrimSuffix(rel, ".md"), "wiki/")] = struct{}{}
+			return nil
+		})
+		if err != nil {
+			return nil, fmt.Errorf("walk %s: %w", dir, err)
+		}
+	}
+	return index, nil
+}
+
+// linkKey normalises a link target for index lookup: an exact path form is
+// tried as written, and anything else falls back to its final segment.
+func linkKey(target string) string {
+	return strings.TrimSuffix(target, ".md")
+}
+
+// codeSpans returns the byte ranges of fenced blocks and inline code spans.
+func codeSpans(content string) [][2]int {
+	var spans [][2]int
+	for _, m := range fencedCodeRE.FindAllStringIndex(content, -1) {
+		spans = append(spans, [2]int{m[0], m[1]})
+	}
+	for _, m := range inlineCodeRE.FindAllStringIndex(content, -1) {
+		spans = append(spans, [2]int{m[0], m[1]})
+	}
+	return spans
+}
+
+// overlaps reports whether [start,end) intersects any span.
+func overlaps(start, end int, spans [][2]int) bool {
+	for _, s := range spans {
+		if start < s[1] && end > s[0] {
+			return true
+		}
+	}
+	return false
+}

ingestion/internal/brain/linkcheck_test.go

@@ -0,0 +1,93 @@
+package brain_test
+
+import (
+	"testing"
+
+	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// seedCorpus writes the two entries every linkcheck case resolves against.
+func seedCorpus(t *testing.T, dir string) {
+	t.Helper()
+	seedNote(t, dir, "wiki/homelab/facts/real-entry.md",
+		"---\nwing: homelab\nhall: facts\ntitle: 'Real entry'\n---\n\nbody.\n")
+	seedNote(t, dir, "knowledge/legacy-entry.md",
+		"---\ntitle: 'Legacy entry'\n---\n\nbody.\n")
+}
+
+func TestStripUnresolvedLinks(t *testing.T) {
+	tests := []struct {
+		name     string
+		body     string
+		want     string
+		stripped []string
+	}{
+		{
+			name: "bare slug that resolves is kept",
+			body: "See [[real-entry]] for the rule.",
+			want: "See [[real-entry]] for the rule.",
+		},
+		{
+			name: "path-style target that resolves is kept",
+			body: "See [[homelab/facts/real-entry]].",
+			want: "See [[homelab/facts/real-entry]].",
+		},
+		{
+			name: "knowledge/ entry resolves by bare slug",
+			body: "See [[legacy-entry]].",
+			want: "See [[legacy-entry]].",
+		},
+		{
+			name:     "unresolvable target is unwrapped to plain text",
+			body:     "Related: [[secret-hygiene]].",
+			want:     "Related: secret-hygiene.",
+			stripped: []string{"secret-hygiene"},
+		},
+		{
+			name:     "unresolvable aliased target keeps its display text",
+			body:     "Related: [[feedback_check_host_not_assume|check the host]].",
+			want:     "Related: check the host.",
+			stripped: []string{"feedback_check_host_not_assume"},
+		},
+		{
+			name: "link inside a fenced code block is left alone",
+			body: "Syntax:\n\n```\n[[wing/hall/slug]]\n```\n",
+			want: "Syntax:\n\n```\n[[wing/hall/slug]]\n```\n",
+		},
+		{
+			name: "link inside an inline code span is left alone",
+			body: "Write `[[wing/hall/slug]]` to link.",
+			want: "Write `[[wing/hall/slug]]` to link.",
+		},
+		{
+			name:     "every unresolvable target is reported once, sorted",
+			body:     "[[zeta-gap]] and [[alpha-gap]] and [[zeta-gap]] again.",
+			want:     "zeta-gap and alpha-gap and zeta-gap again.",
+			stripped: []string{"alpha-gap", "zeta-gap"},
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			dir := t.TempDir()
+			seedCorpus(t, dir)
+
+			got, stripped, err := brain.StripUnresolvedLinks(dir, tc.body)
+			require.NoError(t, err)
+			assert.Equal(t, tc.want, got)
+			assert.Equal(t, tc.stripped, stripped)
+		})
+	}
+}
+
+func TestStripUnresolvedLinks_MissingBrainDirIsNotAGate(t *testing.T) {
+	// A brain dir with no knowledge//wiki/ tree yet must not turn every link
+	// into an unresolved one — an empty corpus is a bootstrap state, not
+	// evidence that the author invented the target.
+	got, stripped, err := brain.StripUnresolvedLinks(t.TempDir(), "See [[real-entry]].")
+	require.NoError(t, err)
+	assert.Equal(t, "See [[real-entry]].", got)
+	assert.Nil(t, stripped)
+}

ingestion/internal/brain/tunnel.go

@@ -54,11 +54,24 @@ func DetectTunnels(brainDir, content string) ([]TunnelCandidate, error) {
 			return nil
 		}
 		title, _ := readTitleAndCreated(path, strings.TrimSuffix(d.Name(), ".md"))
-		needle := strings.ToLower(strings.TrimSpace(title))
+		title = strings.TrimSpace(title)
-		if needle == "" {
+		if title == "" {
 			return nil
 		}
-		idx := strings.Index(lowerContent, needle)
+
+		// A one-word title has to match the prose case-exactly. Matched
+		// case-insensitively, it links every entry that happens to use the
+		// word: "WRONG" (wiki/telos/decisions/wrong.md) collected 185 inbound
+		// See-also links and "Status" 136, making the two most-linked nodes in
+		// the graph artifacts of the English language rather than references.
+		// Multi-word titles keep the case-insensitive match — "risk tier
+		// middleware" in prose is a real mention however it is capitalised,
+		// and a three-word collision is not an accident.
+		haystack, needle := lowerContent, strings.ToLower(title)
+		if isSingleWord(title) {
+			haystack, needle = content, title
+		}
+		idx := strings.Index(haystack, needle)
 		if idx == -1 {
 			return nil
 		}
@@ -69,7 +82,7 @@ func DetectTunnels(brainDir, content string) ([]TunnelCandidate, error) {
 		out = append(out, TunnelCandidate{
 			TargetPath:  filepath.ToSlash(rel),
 			MatchedTerm: title,
-			Exact:       isWholeWord(lowerContent, idx, len(needle)),
+			Exact:       isWholeWord(haystack, idx, len(needle)),
 		})
 		return nil
 	})
@@ -79,6 +92,11 @@ func DetectTunnels(brainDir, content string) ([]TunnelCandidate, error) {
 	return out, nil
 }
 
+// isSingleWord reports whether title is one whitespace-free token.
+func isSingleWord(title string) bool {
+	return !strings.ContainsAny(title, " \t")
+}
+
 // isWholeWord reports whether the substring at [idx, idx+n) in s is
 // bounded by non-alphanumeric characters (or string edges).
 func isWholeWord(s string, idx, n int) bool {

ingestion/internal/brain/tunnel_test.go

@@ -102,16 +102,29 @@ func TestDetectTunnels_ExactTitleMatch(t *testing.T) {
 
 func TestDetectTunnels_FuzzyMatch(t *testing.T) {
 	dir := t.TempDir()
-	seedNote(t, dir, "wiki/x/facts/routing.md",
+	seedNote(t, dir, "wiki/x/facts/routing-table.md",
-		"---\ntitle: Routing\n---\nbody.\n")
+		"---\ntitle: 'Routing Table'\n---\nbody.\n")
 
 	// Substring of title appears in content, but not as a whole word.
-	candidates, err := brain.DetectTunnels(dir, "rerouting handles failover")
+	candidates, err := brain.DetectTunnels(dir, "the routing tables were rebuilt")
 	require.NoError(t, err)
 	require.Len(t, candidates, 1)
 	assert.False(t, candidates[0].Exact, "substring-only match should be fuzzy")
 }
 
+// A one-word title whose only appearance is lowercase inside another word is
+// not even a candidate: it would fill the review file with English rather than
+// with references.
+func TestDetectTunnels_SingleWordSubstringIsNotACandidate(t *testing.T) {
+	dir := t.TempDir()
+	seedNote(t, dir, "wiki/x/facts/routing.md",
+		"---\ntitle: Routing\n---\nbody.\n")
+
+	candidates, err := brain.DetectTunnels(dir, "rerouting handles failover")
+	require.NoError(t, err)
+	assert.Empty(t, candidates)
+}
+
 func TestDetectTunnels_NoFrontmatterFallsBackToSlug(t *testing.T) {
 	dir := t.TempDir()
 	seedNote(t, dir, "wiki/x/facts/widget-flags.md", "# widget flags\n\nbody.\n")
@@ -126,20 +139,21 @@ func TestDetectTunnels_NoFrontmatterFallsBackToSlug(t *testing.T) {
 
 func TestAutoTunnel_FuzzyGoesToCandidatesFile(t *testing.T) {
 	dir := t.TempDir()
-	// Existing note in a different wing whose title is "Routing".
+	// Existing note in a different wing whose title is "Routing Table".
-	seedNote(t, dir, "wiki/other/facts/routing.md",
+	seedNote(t, dir, "wiki/other/facts/routing-table.md",
-		"---\nwing: other\nhall: facts\ntitle: Routing\n---\nbody.\n")
+		"---\nwing: other\nhall: facts\ntitle: 'Routing Table'\n---\nbody.\n")
-	// Source note in another wing whose body mentions "rerouting" (substring match only).
+	// Source note in another wing whose body mentions "routing tables"
+	// (substring match only — the title is not there as a whole word).
 	seedNote(t, dir, "wiki/jepa-fx/facts/new.md",
-		"---\nwing: jepa-fx\nhall: facts\n---\nrerouting traffic\n")
+		"---\nwing: jepa-fx\nhall: facts\n---\nrouting tables rebuilt\n")
 
 	require.NoError(t, brain.AutoTunnel(dir,
-		"wiki/jepa-fx/facts/new.md", "rerouting traffic"))
+		"wiki/jepa-fx/facts/new.md", "routing tables rebuilt"))
 
 	// Source must not get auto-linked (fuzzy).
 	got, err := os.ReadFile(filepath.Join(dir, "wiki/jepa-fx/facts/new.md"))
 	require.NoError(t, err)
-	assert.NotContains(t, string(got), "[[other/facts/routing]]")
+	assert.NotContains(t, string(got), "[[other/facts/routing-table]]")
 
 	// Candidates file must list the pair.
 	matches, err := filepath.Glob(filepath.Join(dir, "raw", "tunnel-candidates-*.md"))
@@ -148,7 +162,7 @@ func TestAutoTunnel_FuzzyGoesToCandidatesFile(t *testing.T) {
 	body, err := os.ReadFile(matches[0])
 	require.NoError(t, err)
 	assert.Contains(t, string(body), "wiki/jepa-fx/facts/new.md")
-	assert.Contains(t, string(body), "wiki/other/facts/routing.md")
+	assert.Contains(t, string(body), "wiki/other/facts/routing-table.md")
 	assert.Contains(t, string(body), "Routing")
 }
 
@@ -175,3 +189,35 @@ func TestWriteTunnel_AppendsToExistingSeeAlso(t *testing.T) {
 	assert.Contains(t, s, "[[a/facts/old]]")
 	assert.Contains(t, s, "[[b/facts/y]]")
 }
+
+// A one-word title matched case-insensitively links every entry that happens
+// to use that word. Live cost before this rule: 185 entries auto-linked to
+// wiki/telos/decisions/wrong.md (title "WRONG") and 136 to .../status.md,
+// making the two most-linked nodes in the graph pure artifacts.
+func TestDetectTunnels_SingleWordTitleNeedsAnExactCaseMatch(t *testing.T) {
+	dir := t.TempDir()
+	seedNote(t, dir, "wiki/telos/decisions/wrong.md",
+		"---\nwing: telos\nhall: decisions\ntitle: WRONG\n---\n# WRONG\n\nRetired beliefs.\n")
+
+	got, err := brain.DetectTunnels(dir, "The obvious fix was to reject the write. Wrong here.")
+	require.NoError(t, err)
+	for _, c := range got {
+		assert.False(t, c.Exact, "a lowercase prose word must not auto-link a one-word title: %+v", c)
+	}
+
+	got, err = brain.DetectTunnels(dir, "The beliefs listed under WRONG were retired.")
+	require.NoError(t, err)
+	require.Len(t, got, 1)
+	assert.True(t, got[0].Exact, "the title's own casing appearing in prose is a real reference")
+}
+
+func TestDetectTunnels_MultiWordTitleStaysCaseInsensitive(t *testing.T) {
+	dir := t.TempDir()
+	seedNote(t, dir, "wiki/homelab/facts/risk-tier.md",
+		"---\nwing: homelab\nhall: facts\ntitle: 'Risk Tier Middleware'\n---\nbody\n")
+
+	got, err := brain.DetectTunnels(dir, "We rebuilt the risk tier middleware last week.")
+	require.NoError(t, err)
+	require.Len(t, got, 1)
+	assert.True(t, got[0].Exact)
+}

ingestion/internal/brainstore/store.go

@@ -42,6 +42,12 @@ func (s *Store) WithGraph(g graphsync.Store) *Store {
 
 // Write creates a brain note and returns its read-after-write handle.
 func (s *Store) Write(ctx context.Context, n capture.Note) (capture.Ref, error) {
+	content, unlinked, err := brain.StripUnresolvedLinks(s.brainDir, n.Content)
+	if err != nil {
+		return capture.Ref{}, err
+	}
+	n.Content = content
+
 	relPath, err := api.WriteNote(s.brainDir, api.WriteNoteOptions{
 		Content:  n.Content,
 		Filename: n.Filename,
@@ -57,13 +63,19 @@ func (s *Store) Write(ctx context.Context, n capture.Note) (capture.Ref, error)
 	s.indexInGraph(ctx, "brain_write", relPath)
 
 	_, _, hash, _ := api.ReadNote(s.brainDir, relPath)
-	return capture.Ref{ID: relPath, Path: relPath, ContentHash: hash}, nil
+	return capture.Ref{ID: relPath, Path: relPath, ContentHash: hash, Unlinked: unlinked}, nil
 }
 
 // Update supersedes an existing note in place. slug may be a bare slug
 // (resolved against n.Wing/n.Hall) or a full brain-relative path (when it
 // contains a slash). It never creates — a missing target is an error.
 func (s *Store) Update(ctx context.Context, slug string, n capture.Note) (capture.Ref, error) {
+	content, unlinked, err := brain.StripUnresolvedLinks(s.brainDir, n.Content)
+	if err != nil {
+		return capture.Ref{}, err
+	}
+	n.Content = content
+
 	opts := api.UpdateNoteOptions{Content: n.Content, Reason: n.Reason}
 	if strings.Contains(slug, "/") {
 		opts.Path = slug
@@ -80,7 +92,7 @@ func (s *Store) Update(ctx context.Context, slug string, n capture.Note) (captur
 	}
 	s.indexInGraph(ctx, "brain_update", relPath)
 
-	return capture.Ref{ID: relPath, Path: relPath, ContentHash: hash, Superseded: true}, nil
+	return capture.Ref{ID: relPath, Path: relPath, ContentHash: hash, Superseded: true, Unlinked: unlinked}, nil
 }
 
 // Get fetches a note by id/path — the read-after-write confirmation

ingestion/internal/brainstore/store_test.go

@@ -83,3 +83,45 @@ func TestStoreGetRoundTripsHash(t *testing.T) {
 	assert.Equal(t, "a", note.Frontmatter["wing"])
 	assert.Contains(t, note.Body, "# Body")
 }
+
+func TestStoreWriteUnwrapsUnresolvedWikilinks(t *testing.T) {
+	dir := t.TempDir()
+	s := brainstore.New(dir)
+	_, err := s.Write(context.Background(), capture.Note{
+		Content: "# Target\n\nbody\n", Filename: "target", Wing: "a", Hall: "facts",
+	})
+	require.NoError(t, err)
+
+	ref, err := s.Write(context.Background(), capture.Note{
+		Content:  "See [[target]] and [[secret-hygiene]].\n",
+		Filename: "src", Wing: "a", Hall: "facts",
+	})
+	require.NoError(t, err)
+	assert.Equal(t, []string{"secret-hygiene"}, ref.Unlinked)
+
+	got, err := os.ReadFile(filepath.Join(dir, "wiki/a/facts/src.md"))
+	require.NoError(t, err)
+	assert.Contains(t, string(got), "[[target]]")
+	assert.Contains(t, string(got), "and secret-hygiene.")
+	assert.NotContains(t, string(got), "[[secret-hygiene]]")
+}
+
+func TestStoreUpdateUnwrapsUnresolvedWikilinks(t *testing.T) {
+	dir := t.TempDir()
+	s := brainstore.New(dir)
+	_, err := s.Write(context.Background(), capture.Note{
+		Content: "old\n", Filename: "n", Wing: "a", Hall: "facts",
+	})
+	require.NoError(t, err)
+
+	ref, err := s.Update(context.Background(), "n", capture.Note{
+		Content: "Related: [[cad-babysit]].\n", Wing: "a", Hall: "facts", Reason: "r",
+	})
+	require.NoError(t, err)
+	assert.Equal(t, []string{"cad-babysit"}, ref.Unlinked)
+
+	got, err := os.ReadFile(filepath.Join(dir, "wiki/a/facts/n.md"))
+	require.NoError(t, err)
+	assert.Contains(t, string(got), "Related: cad-babysit.")
+	assert.NotContains(t, string(got), "[[cad-babysit]]")
+}

ingestion/internal/capture/ports.go

@@ -15,6 +15,10 @@ type Ref struct {
 	Path        string
 	ContentHash string
 	Superseded  bool
+	// Unlinked names the [[wikilink]] targets the store unwrapped to plain
+	// text because they resolve to no entry. Reported rather than rejected:
+	// see brain.StripUnresolvedLinks for why the write still lands.
+	Unlinked []string
 }
 
 // StoredNote is a brain note fetched by Get: the read-after-write

ingestion/internal/capturehttp/handler_test.go

@@ -38,9 +38,11 @@ func (f fakeTracker) CreateIssue(context.Context, string, string, string) (captu
 	}
 	return capture.IssueRef{Repo: "hyperguild", Number: 1, URL: "https://git/1"}, nil
 }
+
 func (fakeTracker) CloseIssue(context.Context, string, int, string) (capture.IssueRef, error) {
 	return capture.IssueRef{}, nil
 }
+
 func (fakeTracker) CommentIssue(context.Context, string, int, string) (capture.IssueRef, error) {
 	return capture.IssueRef{}, nil
 }
@@ -183,6 +185,7 @@ type refusingAudit struct{}
 func (refusingAudit) Reserve(context.Context, classification.Level) (capture.AuditOutcome, error) {
 	return 0, errors.New("central audit sink unreachable")
 }
+
 func (refusingAudit) Record(context.Context, capture.AuditEntry, capture.AuditOutcome) error {
 	return nil
 }

ingestion/internal/claudewatcher/skip_projects_test.go

@@ -0,0 +1,231 @@
+package claudewatcher
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// recordingHandler captures log records so a test can assert that a file was
+// never even attempted — the absence of a read error is the evidence.
+type recordingHandler struct {
+	mu      sync.Mutex
+	records []string
+}
+
+func (h *recordingHandler) Enabled(context.Context, slog.Level) bool { return true }
+
+func (h *recordingHandler) Handle(_ context.Context, r slog.Record) error {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	var sb strings.Builder
+	sb.WriteString(r.Message)
+	r.Attrs(func(a slog.Attr) bool {
+		sb.WriteString(" " + a.Key + "=" + a.Value.String())
+		return true
+	})
+	h.records = append(h.records, sb.String())
+	return nil
+}
+
+func (h *recordingHandler) WithAttrs([]slog.Attr) slog.Handler { return h }
+func (h *recordingHandler) WithGroup(string) slog.Handler      { return h }
+
+func (h *recordingHandler) contains(substr string) bool {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	for _, r := range h.records {
+		if strings.Contains(r, substr) {
+			return true
+		}
+	}
+	return false
+}
+
+func session(t *testing.T, root, project, id string) string {
+	t.Helper()
+	dir := filepath.Join(root, project)
+	require.NoError(t, os.MkdirAll(dir, 0o755))
+	return writeSession(t, dir, id, []string{
+		`{"type":"user","sessionId":"` + id + `","message":"a prompt"}`,
+		`{"type":"assistant","sessionId":"` + id + `","message":{"content":[{"type":"text","text":"an answer"}]}}`,
+	})
+}
+
+// A named project is not ingested, and its neighbours still are.
+func TestSkipProjects_skipsTheNamedProjectOnly(t *testing.T) {
+	tmp := t.TempDir()
+	session(t, tmp, "-home-mathias-dev-AGENTS-cobalt-dingo", "skipped")
+	session(t, tmp, "-home-mathias-dev", "kept")
+
+	sink := &memSink{}
+	require.NoError(t, TickOnce(context.Background(), Config{
+		SessionsDir:  tmp,
+		Host:         "koala",
+		Sink:         sink,
+		SkipProjects: []string{"-home-mathias-dev-AGENTS-cobalt-dingo"},
+	}))
+
+	require.Len(t, sink.batches, 1)
+	assert.Equal(t, "kept", sink.batches[0].SessionID)
+	assert.Equal(t, "-home-mathias-dev", sink.batches[0].ProjectID)
+}
+
+// Globs are necessary, not a convenience. A project directory is derived from
+// the session's WORKING DIRECTORY, so a git worktree produces an ephemeral
+// name like "-home-mathias-dev--claude-worktrees-bridge-cse-017xoC...". An
+// exact-match list could never keep up with those.
+func TestSkipProjects_globMatchesEphemeralWorktreeNames(t *testing.T) {
+	tmp := t.TempDir()
+	session(t, tmp, "-home-mathias-dev--claude-worktrees-bridge-cse-017xoCEcrc35", "worktree")
+	session(t, tmp, "-home-mathias-dev", "kept")
+
+	sink := &memSink{}
+	require.NoError(t, TickOnce(context.Background(), Config{
+		SessionsDir:  tmp,
+		Host:         "koala",
+		Sink:         sink,
+		SkipProjects: []string{"*claude-worktrees-bridge-cse*"},
+	}))
+
+	require.Len(t, sink.batches, 1)
+	assert.Equal(t, "kept", sink.batches[0].SessionID)
+}
+
+// The point of skipping at the directory walk: the file is never OPENED, so
+// its content never enters this process. Proven by making it unreadable — a
+// skipped file produces no read error because nothing tried to read it, while
+// the same file in a non-skipped project does.
+func TestSkipProjects_theFileIsNeverOpened(t *testing.T) {
+	tmp := t.TempDir()
+	path := session(t, tmp, "-home-mathias-dev-AGENTS-cobalt-dingo", "unreadable")
+	require.NoError(t, os.Chmod(path, 0o000))
+	t.Cleanup(func() { _ = os.Chmod(path, 0o644) })
+
+	rec := &recordingHandler{}
+	sink := &memSink{}
+	require.NoError(t, TickOnce(context.Background(), Config{
+		SessionsDir:  tmp,
+		Host:         "koala",
+		Sink:         sink,
+		Logger:       slog.New(rec),
+		SkipProjects: []string{"*cobalt-dingo*"},
+	}))
+
+	assert.Empty(t, sink.batches)
+	assert.False(t, rec.contains("file failed"),
+		"a skipped file must not even be attempted")
+}
+
+// The control test for the one above: without the skip, the unreadable file IS
+// attempted and fails. Otherwise the assertion above could pass for the wrong
+// reason.
+func TestSkipProjects_withoutTheSkipTheSameFileIsAttempted(t *testing.T) {
+	tmp := t.TempDir()
+	path := session(t, tmp, "-home-mathias-dev-AGENTS-cobalt-dingo", "unreadable")
+	require.NoError(t, os.Chmod(path, 0o000))
+	t.Cleanup(func() { _ = os.Chmod(path, 0o644) })
+
+	rec := &recordingHandler{}
+	require.NoError(t, TickOnce(context.Background(), Config{
+		SessionsDir: tmp,
+		Host:        "koala",
+		Sink:        &memSink{},
+		Logger:      slog.New(rec),
+	}))
+
+	assert.True(t, rec.contains("file failed"),
+		"the unreadable file must fail when not skipped — otherwise the skip test proves nothing")
+}
+
+// Patterns match the project directory NAME, not the whole path. A temp
+// directory or a home directory component must not accidentally match and
+// silently disable ingestion.
+func TestSkipProjects_matchesTheProjectNameNotTheFullPath(t *testing.T) {
+	tmp := t.TempDir()
+	session(t, tmp, "-home-mathias-dev", "kept")
+
+	sink := &memSink{}
+	require.NoError(t, TickOnce(context.Background(), Config{
+		SessionsDir: tmp,
+		Host:        "koala",
+		Sink:        sink,
+		// tmp is somewhere under /tmp; this must not match the project name.
+		SkipProjects: []string{"*tmp*"},
+	}))
+
+	require.Len(t, sink.batches, 1, "a path component outside the project name must not match")
+}
+
+// An unparseable pattern must stop the watcher rather than be ignored. A
+// silently dropped skip rule means ingesting what was meant to be excluded,
+// which is the failure that cannot be noticed after the fact.
+func TestSkipProjects_invalidPatternRefusesToRun(t *testing.T) {
+	tmp := t.TempDir()
+	session(t, tmp, "-home-mathias-dev", "kept")
+
+	sink := &memSink{}
+	err := TickOnce(context.Background(), Config{
+		SessionsDir:  tmp,
+		Host:         "koala",
+		Sink:         sink,
+		SkipProjects: []string{"[unclosed"},
+	})
+
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "[unclosed")
+	assert.Empty(t, sink.batches, "nothing may be ingested while a skip rule is broken")
+}
+
+func TestSkipProjects_emptyListChangesNothing(t *testing.T) {
+	tmp := t.TempDir()
+	session(t, tmp, "-home-mathias-dev", "kept")
+
+	sink := &memSink{}
+	require.NoError(t, TickOnce(context.Background(), Config{
+		SessionsDir: tmp, Host: "koala", Sink: sink, SkipProjects: nil,
+	}))
+
+	require.Len(t, sink.batches, 1)
+}
+
+// The difference between SkipDir and filtering after the walk, made
+// observable: an unreadable skipped directory must not disturb anything.
+//
+// Without SkipDir, WalkDir reads the directory's entries, gets a permission
+// error, and that error aborts the ENTIRE walk — so one skipped project with
+// awkward permissions would silently stop ingesting every other project.
+// Returning SkipDir means its contents are never listed at all.
+//
+// Added after a mutation test showed the earlier assertions could not tell the
+// two implementations apart.
+func TestSkipProjects_anUnreadableSkippedDirDoesNotBreakTheWalk(t *testing.T) {
+	tmp := t.TempDir()
+	session(t, tmp, "-home-mathias-dev", "kept")
+
+	blocked := filepath.Join(tmp, "-home-mathias-dev-AGENTS-cobalt-dingo")
+	require.NoError(t, os.MkdirAll(blocked, 0o755))
+	_ = writeSession(t, blocked, "secret", []string{
+		`{"type":"user","sessionId":"secret","message":"should never be read"}`,
+	})
+	require.NoError(t, os.Chmod(blocked, 0o000))
+	t.Cleanup(func() { _ = os.Chmod(blocked, 0o755) })
+
+	sink := &memSink{}
+	require.NoError(t, TickOnce(context.Background(), Config{
+		SessionsDir:  tmp,
+		Host:         "koala",
+		Sink:         sink,
+		SkipProjects: []string{"*cobalt-dingo*"},
+	}))
+
+	require.Len(t, sink.batches, 1, "an unreadable skipped directory must not abort the walk")
+	assert.Equal(t, "kept", sink.batches[0].SessionID)
+}

ingestion/internal/claudewatcher/watcher.go

@@ -45,6 +45,25 @@ type Config struct {
 	Sink        Sink
 	Cursors     *CursorStore
 	Logger      *slog.Logger
+
+	// SkipProjects excludes whole project directories from ingestion, as
+	// filepath.Match globs tested against the project directory NAME (the
+	// basename, e.g. "-home-mathias-dev"), not the full path.
+	//
+	// Globs rather than exact names because a project directory is derived
+	// from the session's working directory, so a git worktree yields an
+	// ephemeral name like
+	// "-home-mathias-dev--claude-worktrees-bridge-cse-017xoC..." that no
+	// exact-match list could keep up with.
+	//
+	// Matching directories are skipped during the directory WALK, so their
+	// files are never opened and their content never enters this process —
+	// which is a stronger property than filtering it out afterwards.
+	//
+	// An unparseable pattern stops the watcher. A silently dropped skip rule
+	// means ingesting what was meant to be excluded, and that is not
+	// noticeable after the fact.
+	SkipProjects []string
 }
 
 // Watch runs the polling loop until ctx is cancelled. Returns ctx.Err()
@@ -68,6 +87,9 @@ func Watch(ctx context.Context, cfg Config) error {
 	if cfg.Logger == nil {
 		cfg.Logger = slog.Default()
 	}
+	if err := validateSkipPatterns(cfg.SkipProjects); err != nil {
+		return err
+	}
 	cfg.Logger.Info("claudewatcher: started",
 		"sessions_dir", cfg.SessionsDir,
 		"host", cfg.Host,
@@ -91,7 +113,7 @@ func Watch(ctx context.Context, cfg Config) error {
 // runTick is one polling pass. Exposed (lowercase) for tests via
 // TickOnce.
 func runTick(ctx context.Context, cfg Config) {
-	files, err := listSessionFiles(cfg.SessionsDir)
+	files, err := listSessionFiles(cfg.SessionsDir, cfg.SkipProjects, cfg.Logger)
 	if err != nil {
 		cfg.Logger.Warn("claudewatcher: list session files", "err", err)
 		return
@@ -119,17 +141,52 @@ func TickOnce(ctx context.Context, cfg Config) error {
 	if cfg.Logger == nil {
 		cfg.Logger = slog.Default()
 	}
+	if err := validateSkipPatterns(cfg.SkipProjects); err != nil {
+		return err
+	}
 	runTick(ctx, cfg)
 	return nil
 }
 
-func listSessionFiles(root string) ([]string, error) {
+// validateSkipPatterns rejects a pattern filepath.Match cannot parse.
+//
+// Checked up front rather than per file: a bad pattern that only failed at
+// match time would be reported once per session file per tick, and — worse —
+// filepath.Match returns an error alongside a false match, so the directory
+// would be ingested while the log complained.
+func validateSkipPatterns(patterns []string) error {
+	for _, p := range patterns {
+		if _, err := filepath.Match(p, "probe"); err != nil {
+			return fmt.Errorf("invalid skip-project pattern %q: %w", p, err)
+		}
+	}
+	return nil
+}
+
+// skipProject reports whether a project directory name matches any pattern.
+func skipProject(name string, patterns []string) bool {
+	for _, p := range patterns {
+		// The error case is already excluded by validateSkipPatterns.
+		if ok, _ := filepath.Match(p, name); ok {
+			return true
+		}
+	}
+	return false
+}
+
+func listSessionFiles(root string, skip []string, log *slog.Logger) ([]string, error) {
 	var out []string
 	err := filepath.WalkDir(root, func(path string, d os.DirEntry, walkErr error) error {
 		if walkErr != nil {
 			return walkErr
 		}
 		if d.IsDir() {
+			// SkipDir, so nothing inside is even listed. The files are never
+			// opened and their content never reaches this process.
+			if path != root && skipProject(d.Name(), skip) {
+				log.Info("claudewatcher: project skipped by configuration", "project", d.Name())
+				return filepath.SkipDir
+			}
 			return nil
 		}
 		if !strings.HasSuffix(path, ".jsonl") {

ingestion/internal/mcp/handlers.go

@@ -233,6 +233,15 @@ type brainWriteArgs struct {
 	Hall     string `json:"hall,omitempty"`
 }
 
+// unlinkedNote explains the `unlinked` field to the caller that caused it.
+// The write landed; what is gone is the [[...]] around a target that names no
+// brain entry. Said here rather than only in a doc comment because the caller
+// is a model that will otherwise repeat it on the next write.
+const unlinkedNote = "these [[wikilink]] targets resolve to no brain entry, " +
+	"so they were unwrapped to plain text. Link only entries that exist " +
+	"(a filename under knowledge/ or wiki/); write the target entry first if " +
+	"you want the link, and keep skills, repos and agent-local memory files as prose."
+
 func (s *Server) brainWrite(ctx context.Context, args json.RawMessage) (json.RawMessage, error) {
 	var a brainWriteArgs
 	if err := json.Unmarshal(args, &a); err != nil {
@@ -253,7 +262,12 @@ func (s *Server) brainWrite(ctx context.Context, args json.RawMessage) (json.Raw
 	if err != nil {
 		return nil, err
 	}
-	return json.Marshal(map[string]string{"id": ref.ID, "path": ref.Path, "content_hash": ref.ContentHash})
+	out := map[string]any{"id": ref.ID, "path": ref.Path, "content_hash": ref.ContentHash}
+	if len(ref.Unlinked) > 0 {
+		out["unlinked"] = ref.Unlinked
+		out["unlinked_note"] = unlinkedNote
+	}
+	return json.Marshal(out)
 }
 
 type brainUpdateArgs struct {
@@ -297,9 +311,14 @@ func (s *Server) brainUpdate(ctx context.Context, args json.RawMessage) (json.Ra
 	if err != nil {
 		return nil, err
 	}
-	return json.Marshal(map[string]any{
+	out := map[string]any{
 		"id": ref.ID, "path": ref.Path, "content_hash": ref.ContentHash, "superseded": ref.Superseded,
-	})
+	}
+	if len(ref.Unlinked) > 0 {
+		out["unlinked"] = ref.Unlinked
+		out["unlinked_note"] = unlinkedNote
+	}
+	return json.Marshal(out)
 }
 
 type brainGetArgs struct {

ingestion/internal/mcp/server_test.go

@@ -134,9 +134,11 @@ type stubTracker struct{}
 func (stubTracker) CreateIssue(context.Context, string, string, string) (capture.IssueRef, error) {
 	return capture.IssueRef{}, nil
 }
+
 func (stubTracker) CloseIssue(context.Context, string, int, string) (capture.IssueRef, error) {
 	return capture.IssueRef{}, nil
 }
+
 func (stubTracker) CommentIssue(context.Context, string, int, string) (capture.IssueRef, error) {
 	return capture.IssueRef{}, nil
 }

ingestion/internal/mcp/tools_capture_test.go

@@ -28,9 +28,11 @@ type capFakeTracker struct{}
 func (capFakeTracker) CreateIssue(context.Context, string, string, string) (capture.IssueRef, error) {
 	return capture.IssueRef{Repo: "hyperguild", Number: 1, URL: "https://git/1"}, nil
 }
+
 func (capFakeTracker) CloseIssue(context.Context, string, int, string) (capture.IssueRef, error) {
 	return capture.IssueRef{}, nil
 }
+
 func (capFakeTracker) CommentIssue(context.Context, string, int, string) (capture.IssueRef, error) {
 	return capture.IssueRef{}, nil
 }

ingestion/internal/startupretry/startupretry_test.go

@@ -18,7 +18,6 @@ func TestDo_ReturnsImmediatelyOnFirstSuccess(t *testing.T) {
 		calls++
 		return "ready", nil
 	})
-
 	if err != nil {
 		t.Fatalf("Do: %v", err)
 	}
@@ -41,7 +40,6 @@ func TestDo_SurvivesTransientFailuresThenSucceeds(t *testing.T) {
 		}
 		return "ready", nil
 	})
-
 	if err != nil {
 		t.Fatalf("Do returned %v — a transient 502 must not be fatal", err)
 	}

ingestion/internal/vectorstore/pg_test.go

@@ -16,6 +16,7 @@ import (
 // reachable database.
 //
 // To run:
+//
 //	BRAIN_PG_TEST_DSN='postgres://brain_app:pwd@127.0.0.1:5432/brain' \
 //	go test ./internal/vectorstore/... -run Integration
 func dsn(t *testing.T) string {

internal/auth/jwt_test.go

@@ -10,10 +10,10 @@ import (
 	"testing"
 	"time"
 
+	"git.d-ma.be/mathias/hyperguild/internal/auth"
 	"github.com/lestrrat-go/jwx/v2/jwa"
 	"github.com/lestrrat-go/jwx/v2/jwk"
 	"github.com/lestrrat-go/jwx/v2/jwt"
-	"git.d-ma.be/mathias/hyperguild/internal/auth"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )

internal/config/models_test.go

@@ -30,7 +30,7 @@ skills:
 func writeModels(t *testing.T, content string) string {
 	t.Helper()
 	f := filepath.Join(t.TempDir(), "models.yaml")
-	require.NoError(t, os.WriteFile(f, []byte(content), 0644))
+	require.NoError(t, os.WriteFile(f, []byte(content), 0o644))
 	return f
 }
 

internal/registry/registry_test.go

@@ -22,6 +22,7 @@ func (s stubSkill) Tools() []registry.ToolDef {
 		InputSchema: json.RawMessage(`{"type":"object","properties":{}}`),
 	}}
 }
+
 func (s stubSkill) Handle(ctx context.Context, tool string, args json.RawMessage) (json.RawMessage, error) {
 	return json.RawMessage(`{"ok":true}`), nil
 }