fix(ingestion): close the PR #152 review findings on REST auth

- main.go's wiring was untested (the test built its own copy of the
  router, so dropping auth in main or re-registering POST /query as
  public stayed green). Routing is now one function, buildMux, which
  main calls and the tests call: it constructs the bearer middleware
  itself, registers public handlers only for patterns on a fixed
  allowlist (a public REST pattern would beat the authenticated
  catch-all by specificity), refuses an empty token, and returns an
  http.Handler so nothing can add a route to the result.
- hyperguild CLI: PassRate sent no token and would 401. Every request
  now goes through brainClient.do, which adds it; the test covers
  Query, Write and PassRate and is named for that.
- ResolveIngestPath returns one refusal for every bad path; the raw
  EvalSymlinks error let a caller probe which server files exist and
  leaked the brain directory.
- PROJECT.md (and derived adapters) and the pass-rate runbook state
  that the REST API needs BRAIN_MCP_TOKEN and is tailnet/in-cluster.

Refs #149

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

ingestion/cmd/server/jwt_validator.go

@@ -1,26 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"log/slog"
-
-	chassisauth "git.d-ma.be/mathias/mcp-chassis/auth"
-)
-
-// buildJWTValidator builds the JWT validator for issuer (nil when issuer is
-// empty: JWT auth disabled). Since mcp-chassis v0.7 construction no longer
-// fails when OIDC discovery does (mcp-chassis#4): the issuer resolves lazily,
-// and until it does a JWT is answered 503-and-retry, not 401. That replaces
-// #83's boot-time retry loop (hyperguild#155). An issuer still unresolved at
-// boot is logged, so a misconfigured issuer is visible rather than silent.
-func buildJWTValidator(ctx context.Context, logger *slog.Logger, issuer, audience string) (*chassisauth.JWTValidator, error) {
-	v, err := chassisauth.NewJWTValidator(ctx, issuer, audience)
-	if err != nil {
-		return nil, fmt.Errorf("build jwt validator: %w", err)
-	}
-	if ok, rerr := v.Ready(ctx); !ok {
-		logger.Warn("jwt issuer not resolved at boot; JWTs answer 503 until it is", "issuer", issuer, "err", rerr)
-	}
-	return v, nil
-}

ingestion/cmd/server/jwt_validator_test.go

@@ -1,111 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"log/slog"
-	"net/http"
-	"net/http/httptest"
-	"sync/atomic"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/metrics"
-)
-
-// fakeIssuer answers OIDC discovery with 502 for the first fail requests, as
-// ingress does while dex is not yet serving on a cold boot (#83), then with a
-// real discovery document and an empty JWKS.
-func fakeIssuer(t *testing.T, fail int32) (*httptest.Server, *atomic.Int32) {
-	t.Helper()
-	var discoveries atomic.Int32
-	mux := http.NewServeMux()
-	var srv *httptest.Server
-	mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, _ *http.Request) {
-		if discoveries.Add(1) <= fail {
-			w.WriteHeader(http.StatusBadGateway)
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = io.WriteString(w, `{"issuer":"`+srv.URL+`","jwks_uri":"`+srv.URL+`/keys"}`)
-	})
-	mux.HandleFunc("/keys", func(w http.ResponseWriter, _ *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = io.WriteString(w, `{"keys":[]}`)
-	})
-	srv = httptest.NewServer(mux)
-	t.Cleanup(srv.Close)
-	return srv, &discoveries
-}
-
-// #83 retried discovery at boot because chassis v0.2.0 failed construction on
-// a 502. Since chassis v0.7 (mcp-chassis#4) the validator is built anyway and
-// resolves the issuer lazily, so boot no longer waits or exits on it
-// (hyperguild#155). An unresolved issuer is logged at boot.
-func TestBuildJWTValidatorReturnsAValidatorWhileDiscovery502s(t *testing.T) {
-	srv, _ := fakeIssuer(t, 1000)
-	var buf bytes.Buffer
-	v, err := buildJWTValidator(context.Background(), slog.New(slog.NewTextHandler(&buf, nil)), srv.URL, "brain")
-	require.NoError(t, err)
-	assert.NotNil(t, v)
-	assert.Contains(t, buf.String(), "jwt issuer not resolved at boot")
-}
-
-func TestBuildJWTValidatorLogsNothingAgainstAHealthyIssuer(t *testing.T) {
-	srv, _ := fakeIssuer(t, 0)
-	var buf bytes.Buffer
-	v, err := buildJWTValidator(context.Background(), slog.New(slog.NewTextHandler(&buf, nil)), srv.URL, "brain")
-	require.NoError(t, err)
-	assert.NotNil(t, v)
-	assert.NotContains(t, buf.String(), "not resolved")
-}
-
-func TestBuildJWTValidatorIsNilWithoutAnIssuer(t *testing.T) {
-	v, err := buildJWTValidator(context.Background(), slog.New(slog.DiscardHandler), "", "brain")
-	require.NoError(t, err)
-	assert.Nil(t, v)
-}
-
-// With the issuer unresolved, a JWT on a REST route answers 503 (retry), not
-// 401: the token may be fine, the server just cannot check it yet.
-func TestBuildMuxAnswers503ToAJWTWhileTheIssuerIsUnresolved(t *testing.T) {
-	srv, _ := fakeIssuer(t, 1000)
-	v, err := buildJWTValidator(context.Background(), slog.New(slog.DiscardHandler), srv.URL, "brain")
-	require.NoError(t, err)
-	mux, err := buildMux(restAuth{token: routesTok, validator: v, realm: "brain"}, testHandler(t),
-		okHandler("mcp"), metrics.New(), nil)
-	require.NoError(t, err)
-	code, _ := do(t, mux, "GET", "/pending", "Bearer aaa.bbb.ccc")
-	assert.Equal(t, http.StatusServiceUnavailable, code)
-}
-
-// PR #183 review: /mcp shares REST's bearer, but only the static token was
-// asserted on it. With the issuer unresolved, a JWT on /mcp answers 503 too,
-// so /mcp's middleware was built with the JWT validator.
-func TestBuildMuxAnswers503ToAJWTOnMCPWhileTheIssuerIsUnresolved(t *testing.T) {
-	srv, _ := fakeIssuer(t, 1000)
-	v, err := buildJWTValidator(context.Background(), slog.New(slog.DiscardHandler), srv.URL, "brain")
-	require.NoError(t, err)
-	mux, err := buildMux(restAuth{token: routesTok, validator: v, realm: "brain"}, testHandler(t),
-		okHandler("mcp"), metrics.New(), nil)
-	require.NoError(t, err)
-	code, _ := do(t, mux, "POST", "/mcp", "Bearer aaa.bbb.ccc")
-	assert.Equal(t, http.StatusServiceUnavailable, code)
-}
-
-// PR #183 review: a 401 on /mcp names the protected-resource metadata in
-// WWW-Authenticate (what the claude.ai OAuth connector discovers from), so
-// /mcp's middleware was built with resourceMetadataURL.
-func TestBuildMuxMCP401CarriesResourceMetadataInWWWAuthenticate(t *testing.T) {
-	const rm = "https://brain.example/.well-known/oauth-protected-resource"
-	mux, err := buildMux(restAuth{token: routesTok, realm: "brain", resourceMetadataURL: rm}, testHandler(t),
-		okHandler("mcp"), metrics.New(), nil)
-	require.NoError(t, err)
-	rec := httptest.NewRecorder()
-	mux.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/mcp", nil))
-	require.Equal(t, http.StatusUnauthorized, rec.Code)
-	assert.Contains(t, rec.Header().Get("WWW-Authenticate"), `resource_metadata="`+rm+`"`)
-}

ingestion/cmd/server/main.go

@@ -32,7 +32,7 @@ import (
 	"github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/reranker"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/search"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/symlinkguard"
+	"github.com/mathiasbq/hyperguild/ingestion/internal/startupretry"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/vectorstore"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/watcher"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/webhook"
@@ -173,8 +173,7 @@ func alertingWarnings(getenv func(string) string) []string {
 	var out []string
 	if getenv("BRAIN_NTFY_URL") == "" {
 		out = append(out, "alerting DISABLED: BRAIN_NTFY_URL unset — "+
-			"brain_edit_root governance rewrites, capture audit degradation and the "+
-			"brain symlink tripwire (hyperguild#157) will not notify")
+			"brain_edit_root governance rewrites and capture audit degradation will not notify")
 	}
 	return out
 }
@@ -240,10 +239,6 @@ func main() {
 	}
 
 	brainDir := envOr("INGEST_BRAIN_DIR", "../brain")
-	if err := startupSymlinkCheck(brainDir); err != nil {
-		logger.Error("brain symlink tripwire", "err", err)
-		os.Exit(1)
-	}
 	port := envOr("INGEST_PORT", "3300")
 
 	llmURL := envOr("INGEST_LLM_URL", "http://iguana:4000/v1")
@@ -365,18 +360,28 @@ func main() {
 	}
 
 	ctx := context.Background()
-	// hyperguild#157: report a symlink that appears in the brain while running.
-	go symlinkguard.Watch(ctx, brainDir, symlinkScanInterval(os.Getenv), buildNotifier())
 
-	// Never fatal on an unreachable issuer (#83): on a cold cluster boot this
-	// pod can beat dex to serving and get a 502 from ingress, and exiting meant
-	// CrashLoopBackOff redoing the backfill. Since mcp-chassis v0.7 the
-	// validator resolves the issuer lazily and answers JWTs 503-and-retry until
-	// it does (hyperguild#155), so no boot retry is needed. A misconfigured
-	// issuer no longer exits the process: it is logged at boot and every JWT
-	// gets 503; the static bearer keeps working.
-	jwtValidator, err := buildJWTValidator(ctx, logger,
-		os.Getenv("DEX_ISSUER_URL"), os.Getenv("MCP_AUDIENCE"))
+	// Built before the watcher, the graph backfill and session ingestion, and
+	// retried rather than fatal (#83). Two separate reasons:
+	//
+	//   - On a cold cluster boot this pod can beat dex to serving and gets a
+	//     502 from ingress. Nothing is misconfigured; it simply started first.
+	//     Exiting there meant CrashLoopBackOff redoing the backfill on every
+	//     attempt, with exponential backoff stretching the brain outage.
+	//   - Constructing it first means a genuine config error (wrong issuer,
+	//     bad audience) fails in seconds instead of after all that work.
+	//
+	// The budget stays bounded: retrying forever would turn a misconfiguration
+	// into a process that looks alive and never serves.
+	jwtValidator, err := startupretry.Do(ctx,
+		startupretry.Policy{Attempts: 8, Base: time.Second, Max: 30 * time.Second},
+		func(ctx context.Context) (*chassisauth.JWTValidator, error) {
+			v, err := chassisauth.NewJWTValidator(ctx, os.Getenv("DEX_ISSUER_URL"), os.Getenv("MCP_AUDIENCE"))
+			if err != nil {
+				logger.Warn("oidc discovery not ready, retrying", "err", err)
+			}
+			return v, err
+		})
 	if err != nil {
 		logger.Error("build jwt validator", "err", err)
 		os.Exit(1)
@@ -516,6 +521,8 @@ func main() {
 		}
 	}
 
+	public["/mcp"] = chassisauth.BearerMiddleware(mcpToken, jwtValidator, "brain", resourceMetadataURL, mcpSrv)
+
 	// POST /capture (#53/#54): the uniform capture REST door. Needs a ticket
 	// tracker to file action items, so it only mounts when Gitea is
 	// configured. It reuses the MCP server's graph-wired brain store (one
@@ -539,7 +546,7 @@ func main() {
 		public["POST /capture"] = captureH
 		// Same use-case behind the MCP `capture` tool (#55 relay) so MCP-native
 		// harnesses (claude.ai, Crush, Pi, LLM Council) reach capture through
-		// the existing /mcp OAuth connector. buildMux wraps this same mcpSrv;
+		// the existing /mcp OAuth connector. mcpSrv is already wrapped above;
 		// WithCapture mutates the same instance, so the tool appears live.
 		mcpSrv.WithCapture(captureSvc, jwtValidator, mcpToken, "local-cli", resolver)
 		// hyperguild#97: a governance-file rewrite gets the same trail a
@@ -581,18 +588,19 @@ func main() {
 		os.Exit(1)
 	}
 
-	// /metrics — unauthenticated Prometheus endpoint, scraped via the
-	// ServiceMonitor in k3s/apps/supervisor/. buildMux registers it and wraps
-	// the whole router in the registry's middleware.
-	//
-	// The whole router, /mcp's bearer included, is built in buildMux so its
-	// tests are tests of production wiring (PR #152 review, hyperguild#154).
-	// The REST API's credential is the same as /mcp's. Untested here: the
-	// restAuth fields and the public map this call passes in (e.g. a nil
-	// validator would drop JWT auth on /mcp and REST and the suite stays
-	// green), and ListenAndServe serving the result unchanged (hyperguild#182).
-	handler, err := buildMux(restAuth{token: mcpToken, validator: jwtValidator, realm: "brain",
-		resourceMetadataURL: resourceMetadataURL}, h, mcpSrv, metrics.New(), public)
+	// /metrics — unauthenticated Prometheus endpoint. kube-prometheus-stack
+	// scrapes it via the ServiceMonitor in k3s/apps/supervisor/. The metrics
+	// middleware below wraps every other registered handler so it observes
+	// real request latency. /metrics itself is excluded from its own
+	// observation by registering it on the outer mux (post-wrap).
+	reg := metrics.New()
+	public["GET /metrics"] = http.HandlerFunc(reg.Handler())
+
+	// The whole router, built in one place so the test of buildMux is a test
+	// of production wiring (PR #152 review). The REST API's credential is the
+	// same as /mcp's.
+	mux, err := buildMux(restAuth{token: mcpToken, validator: jwtValidator, realm: "brain",
+		resourceMetadataURL: resourceMetadataURL}, h, public)
 	if err != nil {
 		logger.Error("build router", "err", err)
 		os.Exit(1)
@@ -613,7 +621,7 @@ func main() {
 		"watch_interval", watchIntervalLog,
 		"mcp_enabled", true,
 	)
-	if err := http.ListenAndServe(addr, handler); err != nil {
+	if err := http.ListenAndServe(addr, reg.Middleware(mux)); err != nil {
 		logger.Error("server stopped", "err", err)
 		os.Exit(1)
 	}

ingestion/cmd/server/routes.go

@@ -8,22 +8,22 @@ import (
 	chassisauth "git.d-ma.be/mathias/mcp-chassis/auth"
 
 	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/metrics"
 )
 
-// publicRoutes is the complete set of patterns a caller may register on the
-// outer mux, outside the REST API's auth (hyperguild#149). Each authenticates
-// itself or is meant to be open: /capture (bearer/JWT), the webhook (HMAC),
-// /oauth/token (client secret) and OAuth metadata (open). /mcp and /metrics
-// are not here: buildMux builds them itself (hyperguild#154). A REST pattern
-// added here would beat the authenticated catch-all by specificity and ship
-// open, which is why buildMux refuses anything else.
+// publicRoutes is the complete set of patterns allowed on the outer mux,
+// outside the REST API's auth (hyperguild#149). Each authenticates itself or is
+// meant to be open: /mcp (bearer/JWT), /capture (bearer/JWT), the webhook
+// (HMAC), /oauth/token (client secret), OAuth metadata and /metrics (open).
+// A REST pattern added here would beat the authenticated catch-all by
+// specificity and ship open, which is why buildMux refuses anything else.
 var publicRoutes = map[string]bool{
+	"/mcp":                      true,
 	"POST /capture":             true,
 	"POST /webhooks/brain-sync": true,
 	"GET /.well-known/oauth-protected-resource":   true,
 	"GET /.well-known/oauth-authorization-server": true,
 	"POST /oauth/token":                           true,
+	"GET /metrics":                                true,
 }
 
 // restAuth is the credential the REST API checks: the same as /mcp's.
@@ -34,25 +34,16 @@ type restAuth struct {
 	resourceMetadataURL string
 }
 
-// buildMux builds the handler main passes to ListenAndServe unchanged. The
-// REST API is mounted at "/" and /mcp is registered, both behind bearer auth
-// that buildMux constructs itself from auth (one credential), so a caller
-// cannot pass a no-op. GET /metrics serves reg, and the whole router is
-// wrapped in reg's middleware. Other public handlers are registered as given,
-// and only for patterns on the publicRoutes allowlist. It returns an
-// http.Handler, not the *ServeMux, so nothing can register a route on the
-// result. What stays untested is main's call site: the restAuth fields and
-// the public map main passes in, and ListenAndServe serving this handler
-// unchanged (hyperguild#182). The tests build their own arguments.
-func buildMux(
-	auth restAuth, h *api.Handler, mcpHandler http.Handler, reg *metrics.Registry, public map[string]http.Handler,
-) (http.Handler, error) {
+// buildMux is the server's whole router. The REST API is mounted at "/"
+// behind bearer auth that buildMux constructs itself, so a caller cannot pass
+// a no-op; public handlers are registered as given, and only for patterns on
+// the publicRoutes allowlist. It returns an http.Handler, not the
+// *ServeMux, so nothing can register a route on the result afterwards and
+// bypass the allowlist.
+func buildMux(auth restAuth, h *api.Handler, public map[string]http.Handler) (http.Handler, error) {
 	if auth.token == "" {
 		return nil, errors.New("buildMux: REST auth needs a token")
 	}
-	if mcpHandler == nil || reg == nil {
-		return nil, errors.New("buildMux: needs the MCP handler and the metrics registry")
-	}
 	mux := http.NewServeMux()
 	for pattern, handler := range public {
 		if !publicRoutes[pattern] {
@@ -60,15 +51,10 @@ func buildMux(
 		}
 		mux.Handle(pattern, handler)
 	}
-	bearer := func(next http.Handler) http.Handler {
+	mountREST(mux, h, func(next http.Handler) http.Handler {
 		return chassisauth.BearerMiddleware(auth.token, auth.validator, auth.realm, auth.resourceMetadataURL, next)
-	}
-	mux.Handle("/mcp", bearer(mcpHandler))
-	// /metrics is registered on the mux and so observed by its own
-	// middleware, like any route.
-	mux.Handle("GET /metrics", reg.Handler())
-	mountREST(mux, h, bearer)
-	return reg.Middleware(mux), nil
+	})
+	return mux, nil
 }
 
 // mountREST registers the REST API on its own mux and mounts it at "/" behind
@@ -87,23 +73,5 @@ func mountREST(mux *http.ServeMux, h *api.Handler, auth func(http.Handler) http.
 	rest.HandleFunc("POST /promote", h.Promote)
 	rest.HandleFunc("POST /backfill-embeddings", h.BackfillEmbeddings)
 	rest.HandleFunc("GET /pass-rate", h.PassRate)
-	mux.Handle("/", labelRESTPattern(rest, auth(rest)))
-}
-
-// labelRESTPattern sets the request's Pattern to the REST route it addresses
-// before auth runs, so the metrics middleware (which reads Pattern from the
-// same *http.Request) labels a refused request by its route rather than by
-// the "/" mount (hyperguild#155). A refused request to a path no route
-// matches keeps "/", so for refused requests the label set stays bounded by
-// the registered routes. That bound does not hold for authenticated
-// requests: an unregistered path reaches the REST mux, which 404s with an
-// empty Pattern, and the metrics middleware falls back to the raw URL path
-// (hyperguild#185).
-func labelRESTPattern(rest *http.ServeMux, next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if _, pattern := rest.Handler(r); pattern != "" {
-			r.Pattern = pattern
-		}
-		next.ServeHTTP(w, r)
-	})
+	mux.Handle("/", auth(rest))
 }

ingestion/cmd/server/routes_observability_test.go

@@ -1,88 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"log/slog"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// wrongTokSentinel is a presented credential distinctive enough that any
-// occurrence in a log line is the raw token, not a coincidence.
-const wrongTokSentinel = "wrong-tok-sentinel-q7zx"
-
-// hyperguild#155: since #149 every REST route sits behind BearerMiddleware,
-// and chassis v0.2.0 refused without logging, so an unknown caller got
-// silent 401s. The chassis now writes an `mcp auth rejected` line, and the
-// presented token appears nowhere in the log as a bare value (PR #181
-// review: asserting on the "Bearer " header form could never fail, since
-// the chassis logs fields, not headers).
-func TestBuildMuxRejectionLogLineOmitsTheBarePresentedToken(t *testing.T) {
-	var buf bytes.Buffer
-	prev := slog.Default()
-	slog.SetDefault(slog.New(slog.NewTextHandler(&buf, nil)))
-	t.Cleanup(func() { slog.SetDefault(prev) })
-
-	code, _ := do(t, testMux(t), "POST", "/query", "Bearer "+wrongTokSentinel)
-	require.Equal(t, http.StatusUnauthorized, code)
-	assert.Contains(t, buf.String(), "mcp auth rejected")
-	assert.Contains(t, buf.String(), "path=/query")
-	assert.NotContains(t, buf.String(), wrongTokSentinel, "the rejected token is logged as a bare value")
-	assert.NotContains(t, buf.String(), routesTok, "the valid static token is logged")
-}
-
-// The `mcp auth accepted` line leaves out the valid static token.
-func TestBuildMuxAcceptedLogLineOmitsTheBareStaticToken(t *testing.T) {
-	var buf bytes.Buffer
-	prev := slog.Default()
-	slog.SetDefault(slog.New(slog.NewTextHandler(&buf, nil)))
-	t.Cleanup(func() { slog.SetDefault(prev) })
-
-	code, _ := do(t, testMux(t), "GET", "/pending", "Bearer "+routesTok)
-	require.Equal(t, http.StatusOK, code)
-	assert.Contains(t, buf.String(), "mcp auth accepted")
-	assert.NotContains(t, buf.String(), routesTok, "the accepted static token is logged as a bare value")
-}
-
-// An authenticated REST request is labelled with the REST mux's pattern:
-// the inner mux sets it on the same *http.Request the outer middleware reads.
-func TestMetricsLabelAnAuthenticatedRESTRequestWithItsRoutePattern(t *testing.T) {
-	mux, reg := testMuxAndRegistry(t)
-	code, _ := do(t, mux, "GET", "/pending", "Bearer "+routesTok)
-	require.Equal(t, http.StatusOK, code)
-
-	rec := httptest.NewRecorder()
-	reg.Handler().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
-	assert.Contains(t, rec.Body.String(), `path="GET /pending"`)
-	assert.NotContains(t, rec.Body.String(), `path="/"`)
-}
-
-// hyperguild#155: a request refused by REST auth never reaches the REST mux,
-// so it was labelled path="/" and a 4xx on /query could not be told from one
-// on /write. It is now labelled with the REST pattern it was addressed to.
-func TestMetricsLabelARejectedRESTRequestWithItsRoutePattern(t *testing.T) {
-	mux, reg := testMuxAndRegistry(t)
-	code, _ := do(t, mux, "POST", "/query", "")
-	require.Equal(t, http.StatusUnauthorized, code)
-
-	rec := httptest.NewRecorder()
-	reg.Handler().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
-	assert.Contains(t, rec.Body.String(), `path="POST /query",status="4xx"`)
-}
-
-// A path no REST route matches keeps the catch-all label, so an attacker
-// probing random URLs cannot grow the series set.
-func TestMetricsLabelARejectedUnknownPathWithTheCatchAll(t *testing.T) {
-	mux, reg := testMuxAndRegistry(t)
-	code, _ := do(t, mux, "POST", "/no-such-route-zq", "")
-	require.Equal(t, http.StatusUnauthorized, code)
-
-	rec := httptest.NewRecorder()
-	reg.Handler().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/metrics", nil))
-	assert.Contains(t, rec.Body.String(), `path="/",status="4xx"`)
-	assert.NotContains(t, rec.Body.String(), "no-such-route-zq")
-}

ingestion/cmd/server/routes_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/metrics"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
 )
 
@@ -22,34 +21,20 @@ func okHandler(body string) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { _, _ = w.Write([]byte(body)) })
 }
 
-// testMux builds the router through buildMux, the function main calls, with
-// every allowlisted public pattern (stub handlers), a stub MCP server and a
-// static token only: no JWT validator and no resourceMetadataURL (the tests
-// in jwt_validator_test.go pass those). It does not use main's own restAuth
-// or public map (hyperguild#182). hyperguild#149: the REST API is
-// authenticated as a whole; the PR #152 review showed a test of a COPY of
-// the router let main.go regress unseen.
+// testMux builds the router exactly as main does: buildMux with the full
+// public set main registers (stub handlers) and real bearer config.
+// hyperguild#149: the REST API is authenticated as a whole; the PR #152
+// review showed a test of a COPY of the router let main.go regress unseen.
 func testMux(t *testing.T) http.Handler {
 	t.Helper()
-	mux, _ := testMuxAndRegistry(t)
-	return mux
-}
-
-func testMuxAndRegistry(t *testing.T) (http.Handler, *metrics.Registry) {
-	t.Helper()
+	h := api.NewHandler(t.TempDir(), slog.New(slog.NewTextHandler(os.Stderr, nil)), pipeline.Config{})
 	public := map[string]http.Handler{}
 	for p := range publicRoutes {
 		public[p] = okHandler("public " + p)
 	}
-	reg := metrics.New()
-	mux, err := buildMux(restAuth{token: routesTok, realm: "brain"}, testHandler(t), okHandler("mcp"), reg, public)
+	mux, err := buildMux(restAuth{token: routesTok, realm: "brain"}, h, public)
 	require.NoError(t, err)
-	return mux, reg
-}
-
-func testHandler(t *testing.T) *api.Handler {
-	t.Helper()
-	return api.NewHandler(t.TempDir(), slog.New(slog.NewTextHandler(os.Stderr, nil)), pipeline.Config{})
+	return mux
 }
 
 func do(t *testing.T, h http.Handler, method, path, authz string) (int, string) {
@@ -89,9 +74,8 @@ func TestBuildMuxAuthenticatesAnUnregisteredPath(t *testing.T) {
 }
 
 // buildMux registers public handlers as given, without adding auth: each
-// public route owns its own (bearer/JWT on /capture, HMAC on the webhook,
-// client secret on /oauth/token) or is meant to be open (OAuth metadata).
-// /mcp and /metrics are not public routes: buildMux builds them itself.
+// public route owns its own (bearer on /mcp, HMAC on the webhook, client
+// secret on /oauth/token) or is meant to be open (/metrics, OAuth metadata).
 func TestBuildMuxDoesNotWrapPublicRoutes(t *testing.T) {
 	r := testMux(t)
 	for p := range publicRoutes {
@@ -109,53 +93,14 @@ func TestBuildMuxDoesNotWrapPublicRoutes(t *testing.T) {
 // over the authenticated catch-all (more specific pattern), so it is refused.
 func TestBuildMuxRefusesAPublicPatternOffTheAllowlist(t *testing.T) {
 	h := api.NewHandler(t.TempDir(), slog.New(slog.NewTextHandler(os.Stderr, nil)), pipeline.Config{})
-	// "/mcp" and "GET /metrics" are built by buildMux itself (hyperguild#154):
-	// passing either as public would register them unauthenticated or twice.
-	for _, p := range []string{"POST /query", "GET /pending", "/", "POST /metrics", "/mcp", "GET /metrics"} {
-		_, err := buildMux(restAuth{token: routesTok, realm: "brain"}, h, okHandler("mcp"), metrics.New(),
-			map[string]http.Handler{p: okHandler("x")})
+	for _, p := range []string{"POST /query", "GET /pending", "/", "POST /metrics"} {
+		_, err := buildMux(restAuth{token: routesTok, realm: "brain"}, h, map[string]http.Handler{p: okHandler("x")})
 		assert.Error(t, err, "public pattern %q must be refused", p)
 	}
 }
 
 func TestBuildMuxRefusesAnEmptyToken(t *testing.T) {
 	h := api.NewHandler(t.TempDir(), slog.New(slog.NewTextHandler(os.Stderr, nil)), pipeline.Config{})
-	_, err := buildMux(restAuth{token: "", realm: "brain"}, h, okHandler("mcp"), metrics.New(), nil)
+	_, err := buildMux(restAuth{token: "", realm: "brain"}, h, nil)
 	assert.Error(t, err)
 }
-
-// hyperguild#154: /mcp's bearer was built in main.go, untested; the buildMux
-// tests used stubs. buildMux now wraps the MCP handler itself, with the same
-// credential as the REST API.
-func TestBuildMuxRefusesMCPWithoutAValidToken(t *testing.T) {
-	r := testMux(t)
-	for _, authz := range []string{"", "Bearer wrong"} {
-		code, body := do(t, r, "POST", "/mcp", authz)
-		assert.Equal(t, http.StatusUnauthorized, code, "authz %q", authz)
-		assert.NotEqual(t, "mcp", body)
-	}
-	code, body := do(t, r, "POST", "/mcp", "Bearer "+routesTok)
-	assert.Equal(t, http.StatusOK, code)
-	assert.Equal(t, "mcp", body)
-}
-
-func TestBuildMuxRefusesANilMCPHandlerOrRegistry(t *testing.T) {
-	auth := restAuth{token: routesTok, realm: "brain"}
-	_, err := buildMux(auth, testHandler(t), nil, metrics.New(), nil)
-	assert.Error(t, err)
-	_, err = buildMux(auth, testHandler(t), okHandler("mcp"), nil, nil)
-	assert.Error(t, err)
-}
-
-// hyperguild#154: main wrapped buildMux's result in the metrics middleware
-// before ListenAndServe, untested. buildMux now returns the handler main
-// serves as-is, metrics included: a request through it is observed and
-// exposed on its own GET /metrics.
-func TestBuildMuxObservesRequestsAndServesMetrics(t *testing.T) {
-	r := testMux(t)
-	code, _ := do(t, r, "GET", "/pending", "Bearer "+routesTok)
-	require.Equal(t, http.StatusOK, code)
-	code, body := do(t, r, "GET", "/metrics", "")
-	require.Equal(t, http.StatusOK, code)
-	assert.Contains(t, body, `path="GET /pending"`)
-}

ingestion/cmd/server/symlink_check.go

@@ -1,39 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/symlinkguard"
-)
-
-// startupSymlinkCheck is the hyperguild#157 tripwire at boot: a symlink in the
-// brain dir would let brain readers serve a file from outside the brain, so
-// the server does not start until it is removed. A directory the scan cannot
-// read could hide one, so it refuses on that too. A missing brain dir (first
-// boot) is the only case it lets pass.
-func startupSymlinkCheck(brainDir string) error {
-	r, err := symlinkguard.Scan(brainDir)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil
-		}
-		return fmt.Errorf("refusing to start: cannot scan the brain dir %s (hyperguild#157): %w", brainDir, err)
-	}
-	if !r.Clean() {
-		return fmt.Errorf("refusing to start: brain dir %s has %s (hyperguild#157); fix them first", brainDir, r)
-	}
-	return nil
-}
-
-// symlinkScanInterval reads BRAIN_SYMLINK_SCAN_INTERVAL (seconds), falling
-// back to the default on an unset, non-numeric or non-positive value.
-func symlinkScanInterval(getenv func(string) string) time.Duration {
-	if s, err := strconv.Atoi(getenv("BRAIN_SYMLINK_SCAN_INTERVAL")); err == nil && s > 0 {
-		return time.Duration(s) * time.Second
-	}
-	return symlinkguard.DefaultInterval
-}

ingestion/cmd/server/symlink_check_test.go

@@ -1,65 +0,0 @@
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// hyperguild#157: the server refuses to start while a symlink exists in the
-// brain dir, or while any part of it cannot be scanned (which could hide
-// one); a missing brain dir is the only thing it lets pass.
-func TestStartupSymlinkCheckRefusesABrainWithASymlink(t *testing.T) {
-	brain := t.TempDir()
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "planted")))
-	err := startupSymlinkCheck(brain)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "planted")
-}
-
-func TestStartupSymlinkCheckRefusesABrainWithAnUnreadableDir(t *testing.T) {
-	if os.Geteuid() == 0 {
-		t.Skip("root reads mode-000 directories")
-	}
-	brain := t.TempDir()
-	locked := filepath.Join(brain, "aaa")
-	require.NoError(t, os.MkdirAll(locked, 0o755))
-	require.NoError(t, os.Chmod(locked, 0o000))
-	t.Cleanup(func() { _ = os.Chmod(locked, 0o755) })
-	err := startupSymlinkCheck(brain)
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "aaa")
-}
-
-func TestStartupSymlinkCheckPassesACleanOrMissingBrain(t *testing.T) {
-	brain := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "n.md"), []byte("x"), 0o644))
-	assert.NoError(t, startupSymlinkCheck(brain))
-	assert.NoError(t, startupSymlinkCheck(filepath.Join(brain, "missing")))
-}
-
-func TestSymlinkScanIntervalFallsBackOnNonPositive(t *testing.T) {
-	for _, v := range []string{"0", "-5", "", "junk"} {
-		got := symlinkScanInterval(func(string) string { return v })
-		assert.Positive(t, got, "env %q", v)
-	}
-}
-
-func TestAlertingWarningsNamesTheSymlinkTripwire(t *testing.T) {
-	w := strings.Join(alertingWarnings(func(string) string { return "" }), " ")
-	assert.Contains(t, w, "symlink tripwire")
-}
-
-func TestStartupSymlinkCheckRefusesAnUnlistableBrainRoot(t *testing.T) {
-	if os.Geteuid() == 0 {
-		t.Skip("root lists mode-0100 directories")
-	}
-	brain := t.TempDir()
-	require.NoError(t, os.Chmod(brain, 0o100))
-	t.Cleanup(func() { _ = os.Chmod(brain, 0o755) })
-	assert.Error(t, startupSymlinkCheck(brain))
-}

ingestion/go.mod

@@ -34,9 +34,9 @@ require (
 	github.com/rogpeppe/go-internal v1.15.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
-	golang.org/x/net v0.55.0 // indirect
+	golang.org/x/net v0.26.0 // indirect
 	golang.org/x/oauth2 v0.21.0 // indirect
-	golang.org/x/term v0.43.0 // indirect
+	golang.org/x/term v0.28.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	google.golang.org/protobuf v1.34.2 // indirect
 	gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect
@@ -51,7 +51,7 @@ require (
 )
 
 require (
-	git.d-ma.be/mathias/mcp-chassis v0.7.1
+	git.d-ma.be/mathias/mcp-chassis v0.2.0
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect
 	github.com/goccy/go-json v0.10.3 // indirect
@@ -66,9 +66,9 @@ require (
 	github.com/lestrrat-go/option v1.0.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/segmentio/asm v1.2.0 // indirect
-	golang.org/x/crypto v0.51.0 // indirect
-	golang.org/x/sync v0.21.0 // indirect
-	golang.org/x/sys v0.45.0
-	golang.org/x/text v0.39.0 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/sync v0.17.0 // indirect
+	golang.org/x/sys v0.31.0 // indirect
+	golang.org/x/text v0.29.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1
 )

ingestion/go.sum

@@ -1,5 +1,5 @@
-git.d-ma.be/mathias/mcp-chassis v0.7.1 h1:4h8TOBHTA0L/no4IPcr4tLcQtmKUlhE2/cXyPdNFGmM=
-git.d-ma.be/mathias/mcp-chassis v0.7.1/go.mod h1:Ks7EK2UnGAN0H3rJjKUxUagX8/ZBdtLrOlcUbv0RwH8=
+git.d-ma.be/mathias/mcp-chassis v0.2.0 h1:6fLmb7xqRa2nNVWsHaUbbfbArgDXJw/gDhb09clBIjo=
+git.d-ma.be/mathias/mcp-chassis v0.2.0/go.mod h1:Ks7EK2UnGAN0H3rJjKUxUagX8/ZBdtLrOlcUbv0RwH8=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -117,42 +117,42 @@ github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9dec
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.51.0 h1:IBPXwPfKxY7cWQZ38ZCIRPI50YLeevDLlLnyC5wRGTI=
-golang.org/x/crypto v0.51.0/go.mod h1:8AdwkbraGNABw2kOX6YFPs3WM22XqI4EXEd8g+x7Oc8=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8=
-golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww=
+golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
+golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
 golang.org/x/oauth2 v0.21.0 h1:tsimM75w1tF/uws5rbeHzIWxEqElMehnc+iW793zsZs=
 golang.org/x/oauth2 v0.21.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.21.0 h1:HLII4xRRTtCRkxYp4HNFF0Js/Og6q2i++KXbg0gHCwM=
-golang.org/x/sync v0.21.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
+golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY=
-golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/term v0.43.0 h1:S4RLU2sB31O/NCl+zFN9Aru9A/Cq2aqKpTZJ6B+DwT4=
-golang.org/x/term v0.43.0/go.mod h1:lrhlHNdQJHO+1qVYiHfFKVuVioJIheAc3fBSMFYEIsk=
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg=
+golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.39.0 h1:UbZz4pLOvn600D6Oh6GGEI6VAmndrEBLv8/6BEXzyus=
-golang.org/x/text v0.39.0/go.mod h1:3UwRclnC2g0TU9x8PZiyfOajCd1zaUNHF9cvqcQZ+ZM=
+golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
+golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
 golang.org/x/time v0.3.0 h1:rg5rLMjNzMS1RkNLzCG38eapWhnYLFYXDXj2gOlr8j4=
 golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.47.0 h1:7Kn5x/d1svx/PzryTsqeoZN4TZwqeH5pGWjefhLi/1Q=
-golang.org/x/tools v0.47.0/go.mod h1:dFHnyTvFWY212G+h7ZY4Vsp/K3U4/7W9TyVaAul8uCA=
+golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
+golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

ingestion/internal/api/handler.go

@@ -12,8 +12,8 @@ import (
 	"time"
 
 	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/claim"
+	"github.com/mathiasbq/hyperguild/ingestion/internal/extract"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/search"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/vectorstore"
@@ -228,22 +228,14 @@ func writeHallNote(brainDir string, opts WriteNoteOptions) (string, error) {
 	// The directory is created only once the note is known to be writable:
 	// a refused write leaves nothing behind, not even an empty hall dir
 	// (brain#21; provenance refusal joins the envelope refusal here).
-	// Created through the brain root, never through a symlinked wing or
-	// hall directory (hyperguild#188).
-	rel, err := filepath.Rel(brainDir, dest)
-	if err != nil {
-		return "", fmt.Errorf("note path: %w", err)
+	if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+		return "", fmt.Errorf("create hall dir: %w", err)
 	}
-	rel = filepath.ToSlash(rel)
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return "", fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	if err := bfs.PutRegular(rel, []byte(final)); err != nil {
+	if err := os.WriteFile(dest, []byte(final), 0o644); err != nil {
 		return "", fmt.Errorf("write: %w", err)
 	}
-	return rel, nil
+	rel, _ := filepath.Rel(brainDir, dest)
+	return filepath.ToSlash(rel), nil
 }
 
 // scalarValues flattens frontmatter fields to key -> scalar value for
@@ -489,7 +481,7 @@ func (h *Handler) IngestPath(w http.ResponseWriter, r *http.Request) {
 				allWarnings = append(allWarnings, fmt.Sprintf("skipped %s: %v", path, rerr))
 				return nil
 			}
-			content, readErr := ReadIngestFile(h.brainDir, path)
+			content, readErr := extract.Text(path)
 			if readErr != nil {
 				allWarnings = append(allWarnings, fmt.Sprintf("extract %s: %v", path, readErr))
 				return nil
@@ -518,7 +510,7 @@ func (h *Handler) IngestPath(w http.ResponseWriter, r *http.Request) {
 			writeError(w, http.StatusBadRequest, fmt.Sprintf("unsupported file extension: %s", ext))
 			return
 		}
-		content, readErr := ReadIngestFile(h.brainDir, req.Path)
+		content, readErr := extract.Text(req.Path)
 		if readErr != nil {
 			writeError(w, http.StatusInternalServerError, fmt.Sprintf("extract text: %v", readErr))
 			return

ingestion/internal/api/ingestpath_root.go

@@ -2,9 +2,6 @@ package api
 
 import (
 	"errors"
-	"os"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/extract"
 	"path/filepath"
 	"strings"
 )
@@ -22,11 +19,6 @@ func ResolveIngestPath(brainDir, p string) (string, error) {
 	if strings.TrimSpace(p) == "" {
 		return "", ErrOutsideIngestRoot
 	}
-	// raw/ itself must be a real directory: if it were a symlink, containment
-	// inside it would mean nothing (hyperguild#153 item 4).
-	if fi, lerr := os.Lstat(filepath.Join(brainDir, "raw")); lerr != nil || fi.Mode()&os.ModeSymlink != 0 || !fi.IsDir() {
-		return "", ErrOutsideIngestRoot
-	}
 	root, err := filepath.EvalSymlinks(filepath.Join(brainDir, "raw"))
 	if err != nil {
 		return "", ErrOutsideIngestRoot
@@ -44,24 +36,3 @@ func ResolveIngestPath(brainDir, p string) (string, error) {
 	}
 	return real, nil
 }
-
-// ReadIngestFile extracts text from an ingest path already confined by
-// ResolveIngestPath, reading it through the raw/ root rather than reopening
-// the path by name (hyperguild#153 item 3): if the file is swapped for a
-// symlink after the check, the read still cannot leave raw/.
-func ReadIngestFile(brainDir, resolved string) (string, error) {
-	root, rawPath, err := OpenRawRoot(brainDir)
-	if err != nil {
-		return "", ErrOutsideIngestRoot
-	}
-	defer func() { _ = root.Close() }()
-	realRoot, err := filepath.EvalSymlinks(rawPath)
-	if err != nil {
-		return "", ErrOutsideIngestRoot
-	}
-	rel, err := filepath.Rel(realRoot, resolved)
-	if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
-		return "", ErrOutsideIngestRoot
-	}
-	return extract.TextIn(root, rel)
-}

ingestion/internal/api/promote.go

@@ -1,9 +1,7 @@
 package api
 
 import (
-	"errors"
 	"fmt"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -30,25 +28,25 @@ var datePrefix = regexp.MustCompile(`^\d{4}-\d{2}-\d{2}-`)
 // (natural review order). An absent raw/ dir yields an empty slice, not an
 // error. Only .md files are listed; tunnel-candidate files are skipped.
 func ListPending(brainDir string) ([]PendingNote, error) {
-	root, _, err := OpenRawRoot(brainDir)
+	dir := filepath.Join(brainDir, "raw")
+	entries, err := os.ReadDir(dir)
 	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
+		if os.IsNotExist(err) {
 			return []PendingNote{}, nil
 		}
 		return nil, fmt.Errorf("read raw dir: %w", err)
 	}
-	defer func() { _ = root.Close() }()
-	entries, err := fs.ReadDir(root.FS(), ".")
-	if err != nil {
-		return nil, fmt.Errorf("read raw dir: %w", err)
-	}
 
 	out := make([]PendingNote, 0, len(entries))
 	for _, e := range entries {
-		if !e.Type().IsRegular() || !strings.HasSuffix(e.Name(), ".md") || strings.HasPrefix(e.Name(), "tunnel-candidates-") {
-			continue // directories, and symlinks whose target may be anywhere (#153)
+		if e.IsDir() || !strings.HasSuffix(e.Name(), ".md") || strings.HasPrefix(e.Name(), "tunnel-candidates-") {
+			continue
 		}
-		raw, info, readErr := readRawNote(root, e.Name())
+		info, statErr := e.Info()
+		if statErr != nil {
+			continue
+		}
+		raw, readErr := os.ReadFile(filepath.Join(dir, e.Name()))
 		if readErr != nil {
 			continue
 		}
@@ -107,9 +105,12 @@ func PromoteNote(brainDir string, opts PromoteOptions) (string, error) {
 	}
 
 	src := filepath.Join(brainDir, "raw", base)
-	raw, err := readRawSource(brainDir, base)
+	raw, err := os.ReadFile(src)
 	if err != nil {
-		return "", err
+		if os.IsNotExist(err) {
+			return "", fmt.Errorf("pending note %q does not exist in raw/", base)
+		}
+		return "", fmt.Errorf("read source: %w", err)
 	}
 
 	// Collision: never silently overwrite an existing promoted note.
@@ -127,18 +128,18 @@ func PromoteNote(brainDir string, opts PromoteOptions) (string, error) {
 	}
 	fm.set("promoted_at", now)
 
-	// Write-then-delete: the source survives any write failure. Both go
-	// through the brain root (hyperguild#188).
+	if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+		return "", fmt.Errorf("create wing dir: %w", err)
+	}
+	// Write-then-delete: the source survives any write failure.
 	promoted, err := StampProvenance(fm.render()+body, opts.Origin, opts.WrittenBy)
 	if err != nil {
 		return "", err
 	}
-	// Created with O_EXCL: a note that appeared after the collision check
-	// above is never overwritten.
-	if err := createBrainFile(brainDir, dest, []byte(promoted)); err != nil {
+	if err := os.WriteFile(dest, []byte(promoted), 0o644); err != nil {
 		return "", fmt.Errorf("write promoted note: %w", err)
 	}
-	if err := removeBrainFile(brainDir, src); err != nil {
+	if err := os.Remove(src); err != nil {
 		return "", fmt.Errorf("promoted note written but source removal failed: %w", err)
 	}
 
@@ -179,9 +180,12 @@ func RejectNote(brainDir string, opts RejectOptions) (string, error) {
 	}
 
 	src := filepath.Join(brainDir, "raw", base)
-	raw, err := readRawSource(brainDir, base)
+	raw, err := os.ReadFile(src)
 	if err != nil {
-		return "", err
+		if os.IsNotExist(err) {
+			return "", fmt.Errorf("pending note %q does not exist in raw/", base)
+		}
+		return "", fmt.Errorf("read source: %w", err)
 	}
 
 	dest := filepath.Join(brainDir, "raw", "rejected", base)
@@ -196,12 +200,14 @@ func RejectNote(brainDir string, opts RejectOptions) (string, error) {
 		fm.set("reject_reason", opts.Reason)
 	}
 
-	// Write-then-delete: the source survives any write failure. Both go
-	// through the brain root (hyperguild#188).
-	if err := createBrainFile(brainDir, dest, []byte(fm.render()+body)); err != nil {
+	if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
+		return "", fmt.Errorf("create rejected dir: %w", err)
+	}
+	// Write-then-delete: the source survives any write failure.
+	if err := os.WriteFile(dest, []byte(fm.render()+body), 0o644); err != nil {
 		return "", fmt.Errorf("write rejected note: %w", err)
 	}
-	if err := removeBrainFile(brainDir, src); err != nil {
+	if err := os.Remove(src); err != nil {
 		return "", fmt.Errorf("rejected note written but source removal failed: %w", err)
 	}
 
@@ -218,24 +224,3 @@ func excerpt(s string, n int) string {
 	}
 	return strings.TrimSpace(string(r))
 }
-
-// readRawSource reads a pending note for promote/reject through the raw root,
-// refusing symlinks and a symlinked raw/ (hyperguild#153).
-func readRawSource(brainDir, base string) ([]byte, error) {
-	root, _, err := OpenRawRoot(brainDir)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil, fmt.Errorf("pending note %q does not exist in raw/", base)
-		}
-		return nil, fmt.Errorf("read source: %w", err)
-	}
-	defer func() { _ = root.Close() }()
-	raw, _, err := readRawNote(root, base)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil, fmt.Errorf("pending note %q does not exist in raw/", base)
-		}
-		return nil, fmt.Errorf("read source: %w", err)
-	}
-	return raw, nil
-}

ingestion/internal/api/promote_redirect_test.go

@@ -1,87 +0,0 @@
-package api_test
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-)
-
-// hyperguild#188: promote and reject wrote the destination with
-// os.MkdirAll + os.WriteFile by path, so a symlinked wing (promote) or a
-// symlinked raw/rejected (reject) redirected the note; the raw source was
-// then removed.
-func TestPromoteAndRejectRefuseASymlinkedDestinationDirectory(t *testing.T) {
-	brain := t.TempDir()
-	outside := t.TempDir()
-	raw := filepath.Join(brain, "raw")
-	require.NoError(t, os.MkdirAll(raw, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(raw, "2026-10-05-n.md"), []byte("---\ntitle: n\n---\nbody\n"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(outside, filepath.Join(brain, "wiki", "lw")))
-	require.NoError(t, os.Symlink(outside, filepath.Join(raw, "rejected")))
-
-	_, err := api.PromoteNote(brain, api.PromoteOptions{Filename: "2026-10-05-n.md", Wing: "lw", Hall: "facts"})
-	assert.Error(t, err)
-	_, err = api.RejectNote(brain, api.RejectOptions{Filename: "2026-10-05-n.md"})
-	assert.Error(t, err)
-	ents, _ := os.ReadDir(outside)
-	assert.Empty(t, ents, "a note was written outside the brain")
-	_, err = os.Stat(filepath.Join(raw, "2026-10-05-n.md"))
-	assert.NoError(t, err, "the raw source is kept when the write is refused")
-
-	require.NoError(t, os.Remove(filepath.Join(raw, "rejected")))
-	_, err = api.PromoteNote(brain, api.PromoteOptions{Filename: "2026-10-05-n.md", Wing: "w", Hall: "facts"})
-	require.NoError(t, err, "positive control: promote into a real wing")
-}
-
-// StampProvenanceFile read and rewrote the note by path (provenance.ApplyFile).
-func TestStampProvenanceFileRefusesANoteBehindASymlinkedDirectory(t *testing.T) {
-	brain := t.TempDir()
-	victim := filepath.Join(brain, "raw", "facts", "v.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("---\ntitle: v\n---\nuntouched\n"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki", "w"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "facts"), filepath.Join(brain, "wiki", "w", "alias")))
-	assert.Error(t, api.StampProvenanceFile(brain, "wiki/w/alias/v.md", "static", "x"))
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "---\ntitle: v\n---\nuntouched\n", string(got))
-
-	real := filepath.Join(brain, "wiki", "w", "facts", "r.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(real), 0o755))
-	require.NoError(t, os.WriteFile(real, []byte("---\ntitle: r\n---\nbody\n"), 0o644))
-	require.NoError(t, api.StampProvenanceFile(brain, "wiki/w/facts/r.md", "static", "x"), "positive control")
-	got, _ = os.ReadFile(real)
-	assert.Contains(t, string(got), "written_by: x")
-}
-
-// The same through an in-brain symlinked wing and raw/rejected, which
-// os.Root alone would follow.
-func TestPromoteAndRejectRefuseAnInBrainSymlinkedDestinationDirectory(t *testing.T) {
-	brain := t.TempDir()
-	raw := filepath.Join(brain, "raw")
-	require.NoError(t, os.MkdirAll(raw, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(raw, "2026-10-05-n.md"), []byte("---\ntitle: n\n---\nbody\n"), 0o644))
-	target := filepath.Join(brain, "archive")
-	require.NoError(t, os.MkdirAll(target, 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "archive"), filepath.Join(brain, "wiki", "lw")))
-	require.NoError(t, os.Symlink(filepath.Join("..", "archive"), filepath.Join(raw, "rejected")))
-
-	_, err := api.PromoteNote(brain, api.PromoteOptions{Filename: "2026-10-05-n.md", Wing: "lw", Hall: "facts"})
-	assert.Error(t, err)
-	_, err = api.RejectNote(brain, api.RejectOptions{Filename: "2026-10-05-n.md"})
-	assert.Error(t, err)
-	ents, _ := os.ReadDir(target)
-	assert.Empty(t, ents, "a note was written at the in-brain link's target")
-	_, err = os.Stat(filepath.Join(raw, "2026-10-05-n.md"))
-	assert.NoError(t, err, "the raw source is kept")
-
-	require.NoError(t, os.Remove(filepath.Join(raw, "rejected")))
-	_, err = api.RejectNote(brain, api.RejectOptions{Filename: "2026-10-05-n.md"})
-	require.NoError(t, err, "positive control: reject into a real raw/rejected")
-}

ingestion/internal/api/provenance.go

@@ -1,10 +1,6 @@
 package api
 
 import (
-	"fmt"
-	"path/filepath"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/provenance"
 )
 
@@ -15,61 +11,11 @@ func StampProvenance(content, origin, writtenBy string) (string, error) {
 	return provenance.Apply(content, provenance.Stamp{Origin: origin, WrittenBy: writtenBy})
 }
 
-// StampProvenanceFile applies StampProvenance to a brain-relative note path,
-// read and rewritten through the brain root (hyperguild#158).
+// StampProvenanceFile applies StampProvenance to a brain-relative note path.
 func StampProvenanceFile(brainDir, relPath, origin, writtenBy string) error {
-	rel, _, err := resolveWithin(brainDir, relPath)
+	_, abs, err := resolveWithin(brainDir, relPath)
 	if err != nil {
 		return err
 	}
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	b, err := bfs.ReadRegular(rel)
-	if err != nil {
-		return fmt.Errorf("read for provenance: %w", err)
-	}
-	out, err := provenance.Apply(string(b), provenance.Stamp{Origin: origin, WrittenBy: writtenBy})
-	if err != nil {
-		return err
-	}
-	if out == string(b) {
-		return nil
-	}
-	if err := bfs.WriteRegular(rel, []byte(out)); err != nil {
-		return fmt.Errorf("write provenance: %w", err)
-	}
-	return nil
-}
-
-// createBrainFile creates the file at abs (inside brainDir) through the
-// brain root and fails if anything is already there.
-func createBrainFile(brainDir, abs string, data []byte) error {
-	rel, err := filepath.Rel(brainDir, abs)
-	if err != nil {
-		return err
-	}
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	return bfs.CreateRegular(filepath.ToSlash(rel), data)
-}
-
-// removeBrainFile removes the file at abs (inside brainDir) through the
-// brain root.
-func removeBrainFile(brainDir, abs string) error {
-	rel, err := filepath.Rel(brainDir, abs)
-	if err != nil {
-		return err
-	}
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	return bfs.Remove(filepath.ToSlash(rel))
+	return provenance.ApplyFile(abs, provenance.Stamp{Origin: origin, WrittenBy: writtenBy})
 }

ingestion/internal/api/raw_race_test.go

@@ -1,178 +0,0 @@
-package api_test
-
-import (
-	"encoding/base64"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-)
-
-// hyperguild#153 / PR #156: behavioural race tests, so the control does not
-// rest on lints that list forbidden APIs (round 3: an os.ReadFile or
-// Root.ReadFile rewrite passed the lint and leaked 19k times in 4s). A
-// swapper keeps renaming a regular note, a symlink to an outside file, or a
-// FIFO into raw/r.md while the public readers loop. Any leaked byte fails;
-// any hang fails.
-
-const raceSentinel = "SENTINEL-153-RACE"
-
-// startSwapper runs fn until the test ends, and waits for it to exit before
-// t.TempDir's cleanup removes the directory it writes into (hyperguild#162:
-// an unawaited swapper raced the cleanup, "directory not empty").
-func startSwapper(t *testing.T, fn func(stop *atomic.Bool)) {
-	t.Helper()
-	var stop atomic.Bool
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() { defer wg.Done(); fn(&stop) }()
-	t.Cleanup(func() { stop.Store(true); wg.Wait() })
-}
-
-func swap(raw, outside string, fifo bool, stop *atomic.Bool) {
-	tgt := filepath.Join(raw, "r.md")
-	for i := 0; !stop.Load(); i++ {
-		tmp := filepath.Join(raw, ".swap")
-		_ = os.Remove(tmp)
-		switch {
-		case i%2 == 0:
-			_ = os.WriteFile(tmp, []byte("# r\n\ninside"), 0o644)
-		case fifo:
-			_ = syscall.Mkfifo(tmp, 0o644)
-		default:
-			_ = os.Symlink(outside, tmp)
-		}
-		_ = os.Rename(tmp, tgt)
-	}
-}
-
-func raceBrain(t *testing.T) (brain, raw, outside string) {
-	t.Helper()
-	brain = t.TempDir()
-	raw = filepath.Join(brain, "raw")
-	if err := os.MkdirAll(raw, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	outside = filepath.Join(t.TempDir(), "secret.md")
-	if err := os.WriteFile(outside, []byte("# s\n\n"+raceSentinel), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(raw, "r.md"), []byte("# r\n\ninside"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	return brain, raw, outside
-}
-
-// readers runs every public raw/ reader once and returns all text they
-// produced (excerpts, extracted text).
-func readers(brain, raw string) string {
-	var b strings.Builder
-	if ns, err := api.ListPending(brain); err == nil {
-		for _, n := range ns {
-			b.WriteString(n.Excerpt)
-		}
-	}
-	if s, err := api.ReadIngestFile(brain, filepath.Join(raw, "r.md")); err == nil {
-		b.WriteString(s)
-	}
-	return b.String()
-}
-
-func TestRawReadersLeakNothingUnderASymlinkSwapRace(t *testing.T) {
-	brain, raw, outside := raceBrain(t)
-	startSwapper(t, func(stop *atomic.Bool) { swap(raw, outside, false, stop) })
-	leaks, iters := 0, 0
-	for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); iters++ {
-		leaks += strings.Count(readers(brain, raw), raceSentinel)
-	}
-	if leaks > 0 {
-		t.Fatalf("outside file leaked %d times in %d iterations", leaks, iters)
-	}
-	t.Logf("%d iterations, 0 leaks", iters)
-}
-
-func TestRawReadersDoNotHangUnderAFIFOSwapRace(t *testing.T) {
-	brain, raw, outside := raceBrain(t)
-	startSwapper(t, func(stop *atomic.Bool) { swap(raw, outside, true, stop) })
-	var iters atomic.Int64
-	done := make(chan struct{})
-	go func() {
-		for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); {
-			_ = readers(brain, raw)
-			iters.Add(1)
-		}
-		close(done)
-	}()
-	select {
-	case <-done:
-	case <-time.After(6 * time.Second):
-		// Unblock the stuck open so the test process can exit.
-		if f, err := os.OpenFile(filepath.Join(raw, "r.md"), os.O_WRONLY|syscall.O_NONBLOCK, 0); err == nil {
-			_ = f.Close()
-		}
-		t.Fatalf("a raw/ reader hung on a swapped-in FIFO after %d iterations", iters.Load())
-	}
-}
-
-// PR #156 round 4: the pdf/docmark branch of TextIn copies the file through
-// the root to a temp file; pointing the extractor back at the raw/ path by
-// name stayed green because the race tests only used r.md (a stub docmark
-// then received the outside file's bytes 34k times in 4s). This races a
-// symlink into raw/r.docx and has a fake docmark count the sentinel in every
-// document it is sent.
-func TestDocmarkExtractionLeaksNothingUnderASymlinkSwapRace(t *testing.T) {
-	var seen atomic.Int64
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		var req struct {
-			Params struct {
-				Arguments struct {
-					ContentBase64 string `json:"content_base64"`
-				} `json:"arguments"`
-			} `json:"params"`
-		}
-		_ = json.NewDecoder(r.Body).Decode(&req)
-		if b, err := base64.StdEncoding.DecodeString(req.Params.Arguments.ContentBase64); err == nil &&
-			strings.Contains(string(b), raceSentinel) {
-			seen.Add(1)
-		}
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"converted"}]}}`))
-	}))
-	defer srv.Close()
-	t.Setenv("DOCMARK_URL", srv.URL)
-
-	brain, raw, outside := raceBrain(t)
-	tgt := filepath.Join(raw, "r.docx")
-	if err := os.WriteFile(tgt, []byte("inside docx bytes"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	startSwapper(t, func(stop *atomic.Bool) {
-		for i := 0; !stop.Load(); i++ {
-			tmp := filepath.Join(raw, ".swapdocx")
-			_ = os.Remove(tmp)
-			if i%2 == 0 {
-				_ = os.WriteFile(tmp, []byte("inside docx bytes"), 0o644)
-			} else {
-				_ = os.Symlink(outside, tmp)
-			}
-			_ = os.Rename(tmp, tgt)
-		}
-	})
-	iters := 0
-	for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); iters++ {
-		_, _ = api.ReadIngestFile(brain, tgt)
-	}
-	if n := seen.Load(); n > 0 {
-		t.Fatalf("docmark received the outside file %d times in %d iterations", n, iters)
-	}
-	t.Logf("%d iterations, 0 leaks to docmark", iters)
-}

ingestion/internal/api/raw_symlink_test.go

@@ -1,80 +0,0 @@
-package api_test
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-)
-
-// hyperguild#153: readers of brain/raw/ followed symlinks. /pending showed the
-// target's contents and promote would copy it into wiki/ (and brain-sync to
-// Gitea). raw/ is writable via Syncthing, so a symlink there is reachable
-// input. Every raw/ reader now treats a symlink as not-a-note.
-const sentinel153 = "SENTINEL-153-OUTSIDE"
-
-func rawWithSymlink(t *testing.T) (brain string) {
-	t.Helper()
-	brain = t.TempDir()
-	raw := filepath.Join(brain, "raw")
-	require.NoError(t, os.MkdirAll(raw, 0o755))
-	outside := filepath.Join(t.TempDir(), "secret.md")
-	require.NoError(t, os.WriteFile(outside, []byte("---\ncreated_at: 2026-01-01T00:00:00Z\n---\n# s\n\n"+sentinel153), 0o644))
-	require.NoError(t, os.Symlink(outside, filepath.Join(raw, "2026-01-01-leak.md")))
-	require.NoError(t, os.WriteFile(filepath.Join(raw, "2026-01-02-real.md"), []byte("# real\n\nreal body"), 0o644))
-	return brain
-}
-
-func TestListPendingSkipsSymlinkedNotes(t *testing.T) {
-	notes, err := api.ListPending(rawWithSymlink(t))
-	require.NoError(t, err)
-	var names []string
-	for _, n := range notes {
-		names = append(names, n.Filename)
-		assert.NotContains(t, n.Excerpt, sentinel153)
-	}
-	assert.Equal(t, []string{"2026-01-02-real.md"}, names)
-}
-
-func TestPromoteNoteRefusesASymlinkedSource(t *testing.T) {
-	brain := rawWithSymlink(t)
-	_, err := api.PromoteNote(brain, api.PromoteOptions{Filename: "2026-01-01-leak.md", Wing: "testing", Hall: "facts"})
-	require.Error(t, err)
-	_, statErr := os.Stat(filepath.Join(brain, "wiki", "testing", "facts", "leak.md"))
-	assert.True(t, os.IsNotExist(statErr), "nothing may be promoted from a symlink")
-}
-
-func TestRejectNoteRefusesASymlinkedSource(t *testing.T) {
-	brain := rawWithSymlink(t)
-	_, err := api.RejectNote(brain, api.RejectOptions{Filename: "2026-01-01-leak.md"})
-	require.Error(t, err)
-	b, _ := os.ReadFile(filepath.Join(brain, "raw", "rejected", "2026-01-01-leak.md"))
-	assert.False(t, strings.Contains(string(b), sentinel153))
-}
-
-// Item 4: if raw/ itself is a symlink, containment inside it means nothing.
-func TestResolvePendingPromoteRejectAndReadIngestRefuseASymlinkedRawRoot(t *testing.T) {
-	brain := t.TempDir()
-	elsewhere := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(elsewhere, "x.md"), []byte("# x\n\n"+sentinel153), 0o644))
-	require.NoError(t, os.Symlink(elsewhere, filepath.Join(brain, "raw")))
-
-	_, err := api.ResolveIngestPath(brain, "x.md")
-	assert.Error(t, err, "ingest must refuse a symlinked raw/")
-	notes, err := api.ListPending(brain)
-	assert.Error(t, err, "pending must refuse a symlinked raw/")
-	assert.Empty(t, notes)
-	_, err = api.PromoteNote(brain, api.PromoteOptions{Filename: "x.md", Wing: "testing", Hall: "facts"})
-	assert.Error(t, err, "promote must refuse a symlinked raw/")
-	_, err = api.RejectNote(brain, api.RejectOptions{Filename: "x.md"})
-	assert.Error(t, err, "reject must refuse a symlinked raw/")
-	text, err := api.ReadIngestFile(brain, filepath.Join(elsewhere, "x.md"))
-	assert.Error(t, err, "ReadIngestFile must refuse a symlinked raw/")
-	assert.NotContains(t, text, sentinel153)
-	// The watcher's refusal is tested in internal/watcher.
-}

ingestion/internal/api/rawroot.go

@@ -1,67 +0,0 @@
-package api
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/extract"
-)
-
-// errNotANote is returned for a raw/ entry that is not a regular file — in
-// particular a symlink, whose target may be anywhere (hyperguild#153).
-var errNotANote = errors.New("not a regular note file in raw/ (symlinks are refused)")
-
-// errRawNotDir means brain/raw is not a real directory (e.g. a symlink), so
-// containment inside it would mean nothing (hyperguild#153 item 4).
-var errRawNotDir = errors.New("brain/raw is not a real directory")
-
-// OpenRawRoot opens brain/raw as an os.Root, refusing a raw/ that is itself a
-// symlink. Reads through the root cannot leave it, even if an entry is
-// swapped for a symlink between a check and the read. It returns the root
-// and raw/'s path. A missing raw/ returns an error wrapping os.ErrNotExist.
-func OpenRawRoot(brainDir string) (*os.Root, string, error) {
-	p := filepath.Join(brainDir, "raw")
-	fi, err := os.Lstat(p)
-	if err != nil {
-		return nil, "", err
-	}
-	if fi.Mode()&os.ModeSymlink != 0 || !fi.IsDir() {
-		return nil, "", errRawNotDir
-	}
-	r, err := os.OpenRoot(p)
-	if err != nil {
-		return nil, "", fmt.Errorf("open raw root: %w", err)
-	}
-	return r, p, nil
-}
-
-// readRawNote reads one raw/ entry by basename through the root, refusing
-// anything that is not a regular file.
-//
-// Accepted residual: a HARD link to an outside file is a regular file and is
-// read. Syncthing syncs contents, not links, so a peer cannot create one;
-// fs.protected_hardlinks=1 and the pod's secrets live on a different
-// filesystem from the brain volume, so a local caller cannot link them in.
-// Refusing Nlink > 1 is the next step if either assumption changes.
-func readRawNote(r *os.Root, base string) ([]byte, os.FileInfo, error) {
-	fi, err := r.Lstat(base)
-	if err != nil {
-		return nil, nil, err
-	}
-	if !fi.Mode().IsRegular() {
-		return nil, nil, errNotANote
-	}
-	f, _, err := extract.OpenRegular(r, base)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer func() { _ = f.Close() }()
-	b, err := io.ReadAll(f)
-	if err != nil {
-		return nil, nil, err
-	}
-	return b, fi, nil
-}

ingestion/internal/api/readnote_root_test.go

@@ -1,52 +0,0 @@
-package api_test
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-)
-
-// hyperguild#157 slice 2: ReadNote (brain_get, read-after-write) read by
-// path; it now reads through brainfs.
-func TestReadNoteRefusesSymlinksAndSurvivesSwapRaces(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(facts, "leak.md")))
-	_, body, _, err := api.ReadNote(brain, "wiki/w/facts/leak.md")
-	assert.Error(t, err)
-	assert.NotContains(t, body, brainfstest.Sentinel)
-	// A link to a file elsewhere in the brain: os.Root allows it, only the
-	// regular-file check refuses it (hyperguild#171).
-	brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "inlink.md")))
-	_, body, _, err = api.ReadNote(brain, "wiki/w/facts/inlink.md")
-	assert.Error(t, err)
-	assert.NotContains(t, body, brainfstest.Sentinel)
-
-	p := filepath.Join(facts, "r.md")
-	require.NoError(t, os.WriteFile(p, []byte("---\nx: y\n---\ninside"), 0o644))
-	fm, body, _, err := api.ReadNote(brain, "wiki/w/facts/r.md")
-	require.NoError(t, err)
-	assert.Equal(t, "y", fm["x"])
-	assert.Contains(t, body, "inside")
-	read := func() string {
-		fm, body, _, _ := api.ReadNote(brain, "wiki/w/facts/r.md")
-		s := body
-		for k, v := range fm {
-			s += k + v
-		}
-		return s
-	}
-	brainfstest.AssertNoLeak(t, p, "---\nx: y\n---\ninside", 1500*time.Millisecond, read)
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	brainfstest.AssertNoLeakFrom(t, p, "---\nx: y\n---\ninside", inBrain, 1500*time.Millisecond, read)
-	brainfstest.AssertNoHang(t, p, "---\nx: y\n---\ninside", 1500*time.Millisecond, 6*time.Second, func() { _ = read() })
-}

ingestion/internal/api/update.go

@@ -3,18 +3,14 @@ package api
 import (
 	"crypto/sha256"
 	"encoding/hex"
-	"errors"
 	"fmt"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
 	"time"
 
 	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/claim"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/notes"
 )
 
 // ContentHash returns the lowercase hex sha256 of b. It is the note's
@@ -94,23 +90,14 @@ func UpdateNote(brainDir string, opts UpdateNoteOptions) (relPath, contentHash,
 		rel = filepath.ToSlash(rel)
 	}
 
-	// The path is caller-supplied (brain_update): resolve it as brain_edit
-	// does, knowledge/ and wiki/ notes only, and read and rewrite it through
-	// the brain root, never through a symlink (hyperguild#169).
-	t, err := notes.Resolve(brainDir, rel, notes.ScopeNotes)
+	rel, abs, err := resolveWithin(brainDir, rel)
 	if err != nil {
 		return "", "", "", err
 	}
-	rel = t.Rel
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return "", "", "", fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
 
-	prior, err := bfs.ReadRegular(rel)
+	prior, err := os.ReadFile(abs)
 	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
+		if os.IsNotExist(err) {
 			return "", "", "", fmt.Errorf("note %q does not exist: use brain_write to create", rel)
 		}
 		return "", "", "", fmt.Errorf("read target: %w", err)
@@ -176,7 +163,7 @@ func UpdateNote(brainDir string, opts UpdateNoteOptions) (relPath, contentHash,
 		return "", "", "", err
 	}
 	out := []byte(stamped)
-	if err := bfs.WriteRegular(rel, out); err != nil {
+	if err := os.WriteFile(abs, out, 0o644); err != nil {
 		return "", "", "", fmt.Errorf("write: %w", err)
 	}
 	return rel, ContentHash(out), priorHash, nil
@@ -187,17 +174,11 @@ func UpdateNote(brainDir string, opts UpdateNoteOptions) (relPath, contentHash,
 // write primitive behind brain_get: the hash it returns equals the hash
 // brain_write / brain_update returned for the same bytes.
 func ReadNote(brainDir, relPath string) (fm map[string]string, body, contentHash string, err error) {
-	rel, _, err := resolveWithin(brainDir, relPath)
+	_, abs, err := resolveWithin(brainDir, relPath)
 	if err != nil {
 		return nil, "", "", err
 	}
-	// Through the brain root, regular files only (hyperguild#157).
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return nil, "", "", fmt.Errorf("read note: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	raw, err := bfs.ReadRegular(rel)
+	raw, err := os.ReadFile(abs)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil, "", "", fmt.Errorf("note %q does not exist", relPath)

ingestion/internal/api/update_redirect_test.go

@@ -1,36 +0,0 @@
-package api_test
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
-)
-
-// hyperguild#173: a directory symlink inside wiki/ that points elsewhere in
-// the brain redirected brain_update's write (os.Root follows in-root
-// intermediate symlinks). Every directory above the note must be real.
-func TestUpdateNoteRefusesANoteBehindASymlinkedDirectory(t *testing.T) {
-	brain := t.TempDir()
-	victim := filepath.Join(brain, "raw", "facts", "v.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("---\ntitle: v\n---\nuntouched\n"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki", "w"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "facts"), filepath.Join(brain, "wiki", "w", "alias")))
-
-	_, _, _, err := api.UpdateNote(brain, api.UpdateNoteOptions{Path: "wiki/w/alias/v.md", Content: "replaced"})
-	assert.ErrorIs(t, err, brainfs.ErrNotRegular)
-	got, _ := os.ReadFile(victim)
-	assert.Contains(t, string(got), "untouched")
-
-	real := filepath.Join(brain, "wiki", "w", "facts", "r.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(real), 0o755))
-	require.NoError(t, os.WriteFile(real, []byte("---\ntitle: r\n---\nold\n"), 0o644))
-	_, _, _, err = api.UpdateNote(brain, api.UpdateNoteOptions{Path: "wiki/w/facts/r.md", Content: "new"})
-	require.NoError(t, err, "positive control: a note in a real directory is updated")
-}

ingestion/internal/api/update_scope_test.go

@@ -1,112 +0,0 @@
-package api_test
-
-import (
-	"os"
-	"path/filepath"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-)
-
-// brain_update passed the caller's path through resolveWithin, a lexical
-// containment check only: any file in the brain could be superseded
-// (classification.yaml, raw/, sessions/), and a final symlink was written
-// through. It now resolves like brain_edit: knowledge/ and wiki/ notes only,
-// read and rewritten through the brain root.
-func TestUpdateNoteRefusesPathsOutsideKnowledgeAndWikiNotes(t *testing.T) {
-	brain := t.TempDir()
-	files := map[string]string{
-		"classification.yaml": "levels: {}\n",
-		"raw/r.md":            "raw\n",
-		"sessions/s.jsonl":    "{}\n",
-		"wiki/w/facts/ok.md":  "---\ntitle: ok\n---\nold\n",
-		"knowledge/k.md":      "---\ntitle: k\n---\nold\n",
-		"wiki/w/facts/x.txt":  "txt\n",
-	}
-	for rel, body := range files {
-		p := filepath.Join(brain, filepath.FromSlash(rel))
-		require.NoError(t, os.MkdirAll(filepath.Dir(p), 0o755))
-		require.NoError(t, os.WriteFile(p, []byte(body), 0o644))
-	}
-	for _, rel := range []string{"classification.yaml", "raw/r.md", "sessions/s.jsonl", "wiki/w/facts/x.txt", "wiki/w/../../raw/r.md"} {
-		_, _, _, err := api.UpdateNote(brain, api.UpdateNoteOptions{Path: rel, Content: "replaced"})
-		assert.Error(t, err, rel)
-	}
-	for rel, body := range files {
-		if rel == "wiki/w/facts/ok.md" || rel == "knowledge/k.md" {
-			continue
-		}
-		got, err := os.ReadFile(filepath.Join(brain, filepath.FromSlash(rel)))
-		require.NoError(t, err)
-		assert.Equal(t, body, string(got), rel)
-	}
-	for _, rel := range []string{"wiki/w/facts/ok.md", "knowledge/k.md"} {
-		_, _, _, err := api.UpdateNote(brain, api.UpdateNoteOptions{Path: rel, Content: "new body"})
-		require.NoError(t, err, "positive control: %s", rel)
-		got, _ := os.ReadFile(filepath.Join(brain, filepath.FromSlash(rel)))
-		assert.Contains(t, string(got), "new body")
-	}
-}
-
-func TestUpdateNoteDoesNotWriteThroughASymlinkedNote(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	victim := filepath.Join(brain, "raw", "victim.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("untouched\n"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "victim.md"), filepath.Join(facts, "l.md")))
-	_, _, _, err := api.UpdateNote(brain, api.UpdateNoteOptions{Path: "wiki/w/facts/l.md", Content: "replaced"})
-	assert.Error(t, err)
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "untouched\n", string(got))
-}
-
-// The note is swapped between a regular file and an in-brain symlink to a
-// raw/ file while UpdateNote runs: the read and the write each refuse a
-// symlink, so the raw/ file is never rewritten.
-func TestUpdateNoteNeverRewritesASymlinkSwappedInForTheNote(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	victim := filepath.Join(brain, "raw", "victim.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("untouched\n"), 0o644))
-	note := filepath.Join(facts, "n.md")
-	body := "---\ntitle: n\n---\nold\n"
-	require.NoError(t, os.WriteFile(note, []byte(body), 0o644))
-
-	var stop atomic.Bool
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		tmp := note + ".swap"
-		for i := 0; !stop.Load(); i++ {
-			_ = os.Remove(tmp)
-			if i%2 == 0 {
-				_ = os.WriteFile(tmp, []byte(body), 0o644)
-			} else {
-				_ = os.Symlink(filepath.Join("..", "..", "..", "raw", "victim.md"), tmp)
-			}
-			_ = os.Rename(tmp, note)
-		}
-	}()
-	ok := 0
-	for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); {
-		if _, _, _, err := api.UpdateNote(brain, api.UpdateNoteOptions{Path: "wiki/w/facts/n.md", Content: "new"}); err == nil {
-			ok++
-		}
-	}
-	stop.Store(true)
-	wg.Wait()
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "untouched\n", string(got))
-	assert.Positive(t, ok, "positive control: some updates reach the regular note")
-}

ingestion/internal/api/write_redirect_test.go

@@ -1,43 +0,0 @@
-package api_test
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
-)
-
-// hyperguild#188: brain_write created a new note with os.MkdirAll +
-// os.WriteFile by path, so a symlinked wing directory redirected the note
-// elsewhere in the brain or outside it.
-func TestWriteNoteRefusesASymlinkedWing(t *testing.T) {
-	for name, target := range map[string]func(t *testing.T, brain string) string{
-		"in-brain": func(t *testing.T, brain string) string {
-			require.NoError(t, os.MkdirAll(filepath.Join(brain, "raw"), 0o755))
-			return filepath.Join("..", "raw")
-		},
-		"outside": func(t *testing.T, _ string) string { return t.TempDir() },
-	} {
-		t.Run(name, func(t *testing.T) {
-			brain := t.TempDir()
-			require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki"), 0o755))
-			link := target(t, brain)
-			require.NoError(t, os.Symlink(link, filepath.Join(brain, "wiki", "lw")))
-			_, err := api.WriteNote(brain, api.WriteNoteOptions{Wing: "lw", Hall: "facts", Filename: "n", Content: "learning"})
-			assert.Error(t, err)
-			resolved := link
-			if !filepath.IsAbs(resolved) {
-				resolved = filepath.Join(brain, "wiki", link)
-			}
-			_, serr := os.Stat(filepath.Join(resolved, "facts"))
-			assert.True(t, os.IsNotExist(serr), "a hall was created at the link's target")
-
-			_, err = api.WriteNote(brain, api.WriteNoteOptions{Wing: "w", Hall: "facts", Filename: "n", Content: "learning"})
-			require.NoError(t, err, "positive control: a real wing is written")
-		})
-	}
-}

ingestion/internal/audit/ntfy.go

@@ -49,19 +49,7 @@ func (n *NtfyNotifier) Notify(ctx context.Context, msg string) error {
 	}
 	defer func() { _ = resp.Body.Close() }()
 	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return &RejectedError{Status: resp.StatusCode}
+		return fmt.Errorf("ntfy notify: status %d", resp.StatusCode)
 	}
 	return nil
 }
-
-// RejectedError is a non-2xx ntfy response.
-type RejectedError struct{ Status int }
-
-func (e *RejectedError) Error() string { return fmt.Sprintf("ntfy notify: status %d", e.Status) }
-
-// Permanent reports whether resending the same message cannot succeed: a 4xx
-// other than 429 (rate limited). Callers may drop such a message; anything
-// else (5xx, 429, transport errors) is an outage and must be retried.
-func (e *RejectedError) Permanent() bool {
-	return e.Status >= 400 && e.Status < 500 && e.Status != http.StatusTooManyRequests
-}

ingestion/internal/audit/ntfy_rejected_test.go

@@ -1,27 +0,0 @@
-package audit
-
-import (
-	"context"
-	"errors"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// A non-2xx ntfy response is a *RejectedError, and only a client-side refusal
-// other than rate limiting is permanent: callers may drop a message on a
-// permanent rejection and must retry the rest (hyperguild#157, PR #160).
-func TestNotifyClassifiesRejectionsAsPermanentOrNot(t *testing.T) {
-	for status, permanent := range map[int]bool{413: true, 400: true, 403: true, 429: false, 500: false, 503: false} {
-		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) { w.WriteHeader(status) }))
-		err := NewNtfyNotifier(srv.URL, "").Notify(context.Background(), "m")
-		srv.Close()
-		var rej *RejectedError
-		require.True(t, errors.As(err, &rej), "status %d: %v", status, err)
-		assert.Equal(t, status, rej.Status)
-		assert.Equal(t, permanent, rej.Permanent(), "status %d", status)
-	}
-}

ingestion/internal/brain/detect_root_test.go

@@ -1,125 +0,0 @@
-package brain_test
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-)
-
-// hyperguild#174 / #157 slice 5b: DetectTunnels walked wiki/ and opened
-// every note with a blocking os.Open, so a FIFO named *.md anywhere under
-// wiki/ hung every brain_write and brain_update (wikiUpkeep -> AutoTunnel),
-// and a symlinked note's title became a tunnel candidate.
-func TestDetectTunnelsReturnsPromptlyWithAFIFOUnderWikiWithAndWithoutAWriter(t *testing.T) {
-	for _, withWriter := range []bool{false, true} {
-		t.Run(fmt.Sprintf("writer=%v", withWriter), func(t *testing.T) {
-			b := t.TempDir()
-			facts := filepath.Join(b, "wiki", "w", "facts")
-			require.NoError(t, os.MkdirAll(facts, 0o755))
-			require.NoError(t, os.WriteFile(filepath.Join(facts, "ok.md"), []byte("---\ntitle: Zqinside Phrase\n---\n"), 0o644))
-			fifo := filepath.Join(facts, "f.md")
-			require.NoError(t, syscall.Mkfifo(fifo, 0o644))
-			if withWriter {
-				// A writer held open: a reader that opens the FIFO gets no
-				// EOF and parks, unless the FIFO is never opened.
-				w, err := os.OpenFile(fifo, os.O_RDWR, 0)
-				require.NoError(t, err)
-				t.Cleanup(func() { _ = w.Close() })
-			}
-			done := make(chan []brain.TunnelCandidate, 1)
-			go func() {
-				cs, _ := brain.DetectTunnels(b, "text mentioning zqinside phrase here")
-				done <- cs
-			}()
-			select {
-			case cs := <-done:
-				assert.Contains(t, fmt.Sprintf("%+v", cs), "Zqinside Phrase", "positive control")
-			case <-time.After(3 * time.Second):
-				if r, err := os.OpenFile(fifo, os.O_WRONLY|syscall.O_NONBLOCK, 0); err == nil {
-					_ = r.Close()
-				}
-				t.Fatal("DetectTunnels blocked on a FIFO")
-			}
-		})
-	}
-}
-
-func TestDetectTunnelsRefusesSymlinkedNotesAndSurvivesSwapRaces(t *testing.T) {
-	b := t.TempDir()
-	facts := filepath.Join(b, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	// The static note's title differs from the raced note's, so the
-	// harness's "inside was read" floor can only be met by reading r.md.
-	require.NoError(t, os.WriteFile(filepath.Join(facts, "ok.md"), []byte("---\ntitle: Zqstatic Words\n---\n"), 0o644))
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(facts, "out.md")))
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(b, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "in.md")))
-	content := "zqstatic words, zqinside phrase and " + brainfstest.Sentinel
-
-	cs, err := brain.DetectTunnels(b, content)
-	require.NoError(t, err)
-	got := fmt.Sprintf("%+v", cs)
-	assert.Contains(t, got, "Zqstatic Words", "positive control")
-	assert.NotContains(t, got, brainfstest.Sentinel)
-
-	p := filepath.Join(facts, "r.md")
-	read := func() string {
-		cs, _ := brain.DetectTunnels(b, content)
-		return fmt.Sprintf("%+v", cs)
-	}
-	brainfstest.AssertNoLeak(t, p, "---\ntitle: Zqinside Phrase\n---\n", 1500*time.Millisecond, read)
-	brainfstest.AssertNoLeakFrom(t, p, "---\ntitle: Zqinside Phrase\n---\n", inBrain, 1500*time.Millisecond, read)
-}
-
-// A wiki/ that is not a real directory yields no candidates and no error:
-// AutoTunnel runs inside brain_write.
-func TestDetectTunnelsSkipsAWikiThatIsNotARealDirectory(t *testing.T) {
-	b := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "raw", "w", "facts"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(b, "raw", "w", "facts", "r.md"), []byte("---\ntitle: Zqrawonly Phrase\n---\n"), 0o644))
-	require.NoError(t, os.Symlink("raw", filepath.Join(b, "wiki")))
-	cs, err := brain.DetectTunnels(b, "zqrawonly phrase")
-	require.NoError(t, err)
-	assert.Empty(t, cs)
-}
-
-// An unreadable directory under wiki/ is a walk error and DetectTunnels
-// reports it, as filepath.WalkDir did; it is not silently dropped.
-func TestDetectTunnelsReportsAnUnreadableDirectoryUnderWiki(t *testing.T) {
-	if os.Geteuid() == 0 {
-		t.Skip("root ignores directory permissions")
-	}
-	b := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "w", "facts"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(b, "wiki", "w", "facts", "ok.md"), []byte("---\ntitle: Zqinside Phrase\n---\n"), 0o644))
-	locked := filepath.Join(b, "wiki", "other", "locked")
-	require.NoError(t, os.MkdirAll(locked, 0o755))
-	require.NoError(t, os.Chmod(locked, 0o000))
-	t.Cleanup(func() { _ = os.Chmod(locked, 0o755) })
-	_, err := brain.DetectTunnels(b, "zqinside phrase")
-	assert.ErrorIs(t, err, os.ErrPermission)
-}
-
-// _index.md files are generated, not notes: their title never becomes a
-// candidate.
-func TestDetectTunnelsSkipsIndexFiles(t *testing.T) {
-	b := t.TempDir()
-	w := filepath.Join(b, "wiki", "w")
-	require.NoError(t, os.MkdirAll(filepath.Join(w, "facts"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(w, "_index.md"), []byte("---\ntitle: Zqindex Words\n---\n"), 0o644))
-	require.NoError(t, os.WriteFile(filepath.Join(w, "facts", "ok.md"), []byte("---\ntitle: Zqinside Phrase\n---\n"), 0o644))
-	cs, err := brain.DetectTunnels(b, "zqindex words and zqinside phrase")
-	require.NoError(t, err)
-	got := fmt.Sprintf("%+v", cs)
-	assert.Contains(t, got, "Zqinside Phrase", "positive control")
-	assert.NotContains(t, got, "Zqindex")
-}

ingestion/internal/brain/index.go

@@ -2,16 +2,12 @@ package brain
 
 import (
 	"bufio"
-	"bytes"
-	"errors"
 	"fmt"
-	"io"
-	"io/fs"
+	"os"
+	"path/filepath"
 	"sort"
 	"strings"
 	"time"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 )
 
 // noteEntry is one row in a Wing _index.md.
@@ -30,18 +26,14 @@ func BuildWingIndex(brainDir, wing string) error {
 	if w == "" {
 		return fmt.Errorf("invalid wing %q", wing)
 	}
-	// Listed and read through the brain root (hyperguild#157): a wing or
-	// hall that is a symlink is not followed, and notes are regular files.
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	if _, err := bfs.Lstat("wiki/" + w); errors.Is(err, fs.ErrNotExist) {
+	wingDir := filepath.Join(brainDir, "wiki", w)
+	if _, err := os.Stat(wingDir); os.IsNotExist(err) {
 		return nil
+	} else if err != nil {
+		return fmt.Errorf("stat wing: %w", err)
 	}
 
-	entries, err := collectWingEntries(bfs, "wiki/"+w)
+	entries, err := collectWingEntries(wingDir)
 	if err != nil {
 		return err
 	}
@@ -60,85 +52,74 @@ func BuildWingIndex(brainDir, wing string) error {
 		fmt.Fprintf(&b, "| %s | [%s](%s/%s.md) | %s |\n", e.Hall, e.Title, e.Hall, e.Slug, e.Created)
 	}
 
-	// Written through the brain root, never through a symlinked _index.md
-	// (hyperguild#158).
-	return bfs.PutRegular("wiki/"+w+"/_index.md", []byte(b.String()))
+	dest := filepath.Join(wingDir, "_index.md")
+	return os.WriteFile(dest, []byte(b.String()), 0o644)
 }
 
 // BuildAllWingIndexes regenerates _index.md for every wing under brain/wiki/.
 func BuildAllWingIndexes(brainDir string) error {
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
-	}
-	wings, err := bfs.ReadDirDirs("wiki")
-	_ = bfs.Close()
-	if errors.Is(err, fs.ErrNotExist) {
+	wikiDir := filepath.Join(brainDir, "wiki")
+	ents, err := os.ReadDir(wikiDir)
+	if os.IsNotExist(err) {
 		return nil
 	}
 	if err != nil {
 		return fmt.Errorf("read wiki: %w", err)
 	}
-	for _, w := range wings {
-		if err := BuildWingIndex(brainDir, w); err != nil {
-			return fmt.Errorf("index %s: %w", w, err)
+	for _, e := range ents {
+		if !e.IsDir() {
+			continue
+		}
+		if err := BuildWingIndex(brainDir, e.Name()); err != nil {
+			return fmt.Errorf("index %s: %w", e.Name(), err)
 		}
 	}
 	return nil
 }
 
-func collectWingEntries(bfs *brainfs.Brain, wingRel string) ([]noteEntry, error) {
+func collectWingEntries(wingDir string) ([]noteEntry, error) {
 	var out []noteEntry
-	halls, err := bfs.ReadDirDirs(wingRel)
+	ents, err := os.ReadDir(wingDir)
 	if err != nil {
 		return nil, fmt.Errorf("read wing: %w", err)
 	}
-	for _, hall := range halls {
+	for _, hallEnt := range ents {
+		if !hallEnt.IsDir() {
+			continue
+		}
+		hall := hallEnt.Name()
 		if !IsValidHall(hall) {
 			continue
 		}
-		hallRel := wingRel + "/" + hall
-		names, err := bfs.ReadDirRegular(hallRel)
+		hallDir := filepath.Join(wingDir, hall)
+		notes, err := os.ReadDir(hallDir)
 		if err != nil {
 			return nil, fmt.Errorf("read hall %s: %w", hall, err)
 		}
-		for _, name := range names {
-			if !strings.HasSuffix(name, ".md") || name == "_index.md" {
+		for _, n := range notes {
+			if n.IsDir() || !strings.HasSuffix(n.Name(), ".md") || n.Name() == "_index.md" {
 				continue
 			}
-			slug := strings.TrimSuffix(name, ".md")
-			title, created := readTitleAndCreatedIn(bfs, hallRel+"/"+name, slug)
+			slug := strings.TrimSuffix(n.Name(), ".md")
+			full := filepath.Join(hallDir, n.Name())
+			title, created := readTitleAndCreated(full, slug)
 			out = append(out, noteEntry{Hall: hall, Slug: slug, Title: title, Created: created})
 		}
 	}
 	return out, nil
 }
 
-// readTitleAndCreatedIn is readTitleAndCreated through the brain root,
-// regular files only (hyperguild#157).
-func readTitleAndCreatedIn(bfs *brainfs.Brain, rel, slug string) (string, string) {
-	content, err := bfs.ReadRegular(rel)
+// readTitleAndCreated reads YAML frontmatter for title + created_at; falls
+// back to slug and file mtime when absent.
+func readTitleAndCreated(path, slug string) (string, string) {
+	f, err := os.Open(path)
 	if err != nil {
 		return slug, ""
 	}
-	title, created := parseTitleAndCreated(bytes.NewReader(content))
-	if created == "" {
-		if info, err := bfs.Lstat(rel); err == nil {
-			created = info.ModTime().UTC().Format("2006-01-02")
-		}
-	}
-	return titleOrSlug(title, slug), created
-}
+	defer func() { _ = f.Close() }()
 
-func titleOrSlug(title, slug string) string {
-	if title == "" {
-		return strings.ReplaceAll(slug, "-", " ")
-	}
-	return title
-}
-
-func parseTitleAndCreated(r io.Reader) (title, created string) {
-	scanner := bufio.NewScanner(r)
+	title, created := "", ""
+	scanner := bufio.NewScanner(f)
 	inFrontmatter := false
 	for scanner.Scan() {
 		line := scanner.Text()
@@ -168,5 +149,13 @@ func parseTitleAndCreated(r io.Reader) (title, created string) {
 			}
 		}
 	}
+	if title == "" {
+		title = strings.ReplaceAll(slug, "-", " ")
+	}
+	if created == "" {
+		if info, err := os.Stat(path); err == nil {
+			created = info.ModTime().UTC().Format("2006-01-02")
+		}
+	}
 	return title, created
 }

ingestion/internal/brain/index_root_test.go

@@ -1,132 +0,0 @@
-package brain_test
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-)
-
-func readIndex(t *testing.T, brainDir, wing string) string {
-	t.Helper()
-	b, _ := os.ReadFile(filepath.Join(brainDir, "wiki", wing, "_index.md"))
-	return string(b)
-}
-
-// hyperguild#157 slice 5: BuildWingIndex listed wiki/<wing>/<hall>/ with
-// os.ReadDir and opened each note by path, so a symlinked note put the
-// target's title into _index.md, and a FIFO hung the index build.
-func TestBuildWingIndexRefusesSymlinkedNotesAndSurvivesSwapRaces(t *testing.T) {
-	b := t.TempDir()
-	facts := filepath.Join(b, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(facts, "ok.md"), []byte("---\ntitle: zqinside\n---\n"), 0o644))
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(facts, "leak.md")))
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(b, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "inlink.md")))
-
-	require.NoError(t, brain.BuildWingIndex(b, "w"))
-	idx := readIndex(t, b, "w")
-	assert.Contains(t, idx, "zqinside", "positive control")
-	assert.NotContains(t, idx, brainfstest.Sentinel)
-	assert.NotContains(t, idx, "leak")
-	assert.NotContains(t, idx, "inlink")
-
-	p := filepath.Join(facts, "r.md")
-	read := func() string {
-		_ = brain.BuildWingIndex(b, "w")
-		return readIndex(t, b, "w")
-	}
-	brainfstest.AssertNoLeak(t, p, "---\ntitle: zqinside\n---\n", 1500*time.Millisecond, read)
-	brainfstest.AssertNoLeakFrom(t, p, "---\ntitle: zqinside\n---\n", inBrain, 1500*time.Millisecond, read)
-	brainfstest.AssertNoHang(t, p, "---\ntitle: zqinside\n---\n", 1500*time.Millisecond, 6*time.Second, func() { _ = read() })
-}
-
-// A symlinked hall is skipped while a real hall next to it is indexed; a
-// symlinked wing is refused and nothing is written into its target.
-func TestBuildWingIndexSkipsASymlinkedHallAndRefusesASymlinkedWing(t *testing.T) {
-	b := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "raw", "facts"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(b, "raw", "facts", "r.md"), []byte("---\ntitle: zqrawonly\n---\n"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "w", "decisions"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(b, "wiki", "w", "decisions", "d.md"), []byte("---\ntitle: zqrealhall\n---\n"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "facts"), filepath.Join(b, "wiki", "w", "facts")))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(b, "wiki", "alias")))
-
-	require.NoError(t, brain.BuildWingIndex(b, "w"))
-	idx, err := os.ReadFile(filepath.Join(b, "wiki", "w", "_index.md"))
-	require.NoError(t, err, "the wing index is written")
-	assert.Contains(t, string(idx), "zqrealhall", "the real hall is indexed")
-	assert.NotContains(t, string(idx), "zqrawonly", "the symlinked hall is not")
-
-	assert.Error(t, brain.BuildWingIndex(b, "alias"))
-	_, err = os.Stat(filepath.Join(b, "raw", "_index.md"))
-	assert.True(t, os.IsNotExist(err), "an index was written into the symlinked wing's target")
-}
-
-// BuildAllWingIndexes indexes the real wings and skips a symlinked one.
-func TestBuildAllWingIndexesSkipsASymlinkedWing(t *testing.T) {
-	b := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "w", "facts"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(b, "wiki", "w", "facts", "n.md"), []byte("---\ntitle: zqrealwing\n---\n"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "raw", "facts"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(b, "wiki", "alias")))
-
-	require.NoError(t, brain.BuildAllWingIndexes(b))
-	idx, err := os.ReadFile(filepath.Join(b, "wiki", "w", "_index.md"))
-	require.NoError(t, err)
-	assert.Contains(t, string(idx), "zqrealwing")
-	_, err = os.Stat(filepath.Join(b, "raw", "_index.md"))
-	assert.True(t, os.IsNotExist(err))
-}
-
-// A link to a symlinked note does not resolve: only regular files count as
-// entries, so StripUnresolvedLinks unwraps it.
-func TestStripUnresolvedLinksDoesNotCountASymlinkedNoteAsAnEntry(t *testing.T) {
-	b := t.TempDir()
-	facts := filepath.Join(b, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(facts, "real.md"), []byte("x"), 0o644))
-	brainfstest.WriteSentinelAt(t, filepath.Join(b, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "ghost.md")))
-	out, unlinked, err := brain.StripUnresolvedLinks(b, "see [[real]] and [[ghost]]")
-	require.NoError(t, err)
-	assert.Contains(t, out, "[[real]]", "positive control")
-	assert.NotContains(t, out, "[[ghost]]")
-	assert.Contains(t, unlinked, "ghost")
-}
-
-// A linked tree (knowledge/ or wiki/) that is not a real directory is
-// skipped, not an error: StripUnresolvedLinks runs before every brain_write,
-// and an error there loses the learning.
-func TestStripUnresolvedLinksSkipsALinkedTreeThatIsNotARealDirectory(t *testing.T) {
-	for name, mk := range map[string]func(t *testing.T, b string){
-		"symlink to an in-brain dir": func(t *testing.T, b string) {
-			require.NoError(t, os.MkdirAll(filepath.Join(b, "raw", "k"), 0o755))
-			require.NoError(t, os.Symlink(filepath.Join("raw", "k"), filepath.Join(b, "knowledge")))
-		},
-		"dangling symlink": func(t *testing.T, b string) {
-			require.NoError(t, os.Symlink("nowhere", filepath.Join(b, "knowledge")))
-		},
-		"regular file": func(t *testing.T, b string) {
-			require.NoError(t, os.WriteFile(filepath.Join(b, "knowledge"), []byte("x"), 0o644))
-		},
-	} {
-		t.Run(name, func(t *testing.T) {
-			b := t.TempDir()
-			require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "w", "facts"), 0o755))
-			require.NoError(t, os.WriteFile(filepath.Join(b, "wiki", "w", "facts", "real.md"), []byte("x"), 0o644))
-			mk(t, b)
-			out, _, err := brain.StripUnresolvedLinks(b, "learning [[real]] and [[gone]]")
-			require.NoError(t, err)
-			assert.Contains(t, out, "[[real]]", "links into wiki/ still resolve")
-			assert.NotContains(t, out, "[[gone]]")
-		})
-	}
-}

ingestion/internal/brain/linkcheck.go

@@ -1,16 +1,12 @@
 package brain
 
 import (
-	"errors"
 	"fmt"
-	"io/fs"
-	"log/slog"
-	"path"
+	"os"
+	"path/filepath"
 	"regexp"
 	"sort"
 	"strings"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 )
 
 // wikilinkRE matches [[target]] and [[target|Display Text]].
@@ -102,40 +98,29 @@ var linkedTrees = []string{"knowledge", "wiki"}
 // one the audit will also resolve.
 func entryIndex(brainDir string) (map[string]struct{}, error) {
 	index := map[string]struct{}{}
-	// Walked through the brain root (hyperguild#157): only regular files
-	// count as entries, so a symlinked .md name cannot make a link resolve.
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return nil, fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
 	for _, dir := range linkedTrees {
-		if _, err := bfs.Lstat(dir); errors.Is(err, fs.ErrNotExist) {
+		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)
 		}
-		var walkErr error
-		err := bfs.WalkRegular(dir, func(rel string) error {
-			if !strings.HasSuffix(rel, ".md") {
+		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
 			}
-			index[strings.TrimSuffix(path.Base(rel), ".md")] = struct{}{}
+			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
-		}, func(rel string, err error) {
-			// A linked tree that is not a real directory (a symlink, a
-			// file) is skipped, as filepath.WalkDir did: this runs before
-			// every brain_write, and an error here loses the learning.
-			if rel == dir && errors.Is(err, brainfs.ErrNotRegular) {
-				slog.Warn("link check: skipping a linked tree that is not a real directory", "dir", dir)
-				return
-			}
-			if walkErr == nil {
-				walkErr = fmt.Errorf("%s: %w", rel, err)
-			}
 		})
-		if err == nil {
-			err = walkErr
-		}
 		if err != nil {
 			return nil, fmt.Errorf("walk %s: %w", dir, err)
 		}

ingestion/internal/brain/tunnel.go

@@ -2,15 +2,11 @@ package brain
 
 import (
 	"bufio"
-	"errors"
 	"fmt"
-	"io/fs"
-	"path"
+	"os"
 	"path/filepath"
 	"strings"
 	"time"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 )
 
 // seeAlsoHeader is the markdown heading used to group cross-wing links.
@@ -40,29 +36,24 @@ type TunnelCandidate struct {
 // A note's title is read from YAML frontmatter `title:`; failing that,
 // the filename slug (sans `.md`, hyphens → spaces) is used.
 func DetectTunnels(brainDir, content string) ([]TunnelCandidate, error) {
-	// Walked and read through the brain root, regular files only
-	// (hyperguild#174, #157): this runs inside every brain_write, so a FIFO
-	// must not block it and a symlinked note's title must not become a
-	// candidate.
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return nil, fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	if _, err := bfs.Lstat("wiki"); errors.Is(err, fs.ErrNotExist) {
+	wikiDir := filepath.Join(brainDir, "wiki")
+	if _, err := os.Stat(wikiDir); os.IsNotExist(err) {
 		return nil, nil
+	} else if err != nil {
+		return nil, fmt.Errorf("stat wiki: %w", err)
 	}
 
 	lowerContent := strings.ToLower(content)
 
 	var out []TunnelCandidate
-	var walkErr error
-	err = bfs.WalkRegular("wiki", func(rel string) error {
-		name := path.Base(rel)
-		if !strings.HasSuffix(name, ".md") || name == "_index.md" {
+	err := filepath.WalkDir(wikiDir, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if d.IsDir() || !strings.HasSuffix(path, ".md") || d.Name() == "_index.md" {
 			return nil
 		}
-		title, _ := readTitleAndCreatedIn(bfs, rel, strings.TrimSuffix(name, ".md"))
+		title, _ := readTitleAndCreated(path, strings.TrimSuffix(d.Name(), ".md"))
 		title = strings.TrimSpace(title)
 		if title == "" {
 			return nil
@@ -84,25 +75,17 @@ func DetectTunnels(brainDir, content string) ([]TunnelCandidate, error) {
 		if idx == -1 {
 			return nil
 		}
+		rel, err := filepath.Rel(brainDir, path)
+		if err != nil {
+			return err
+		}
 		out = append(out, TunnelCandidate{
-			TargetPath:  rel,
+			TargetPath:  filepath.ToSlash(rel),
 			MatchedTerm: title,
 			Exact:       isWholeWord(haystack, idx, len(needle)),
 		})
 		return nil
-	}, func(rel string, err error) {
-		// A wiki/ that is not a real directory yields no candidates, as
-		// filepath.WalkDir did; other walk errors still abort.
-		if rel == "wiki" && errors.Is(err, brainfs.ErrNotRegular) {
-			return
-		}
-		if walkErr == nil {
-			walkErr = fmt.Errorf("%s: %w", rel, err)
-		}
 	})
-	if err == nil {
-		err = walkErr
-	}
 	if err != nil {
 		return nil, err
 	}
@@ -175,23 +158,35 @@ func logFuzzyCandidates(brainDir, sourcePath string, cs []TunnelCandidate) error
 	if len(cs) == 0 {
 		return nil
 	}
-	// Appended through the brain root, never through a symlinked raw/ or
-	// log file (hyperguild#158).
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
+	rawDir := filepath.Join(brainDir, "raw")
+	if err := os.MkdirAll(rawDir, 0o755); err != nil {
+		return err
 	}
-	defer func() { _ = bfs.Close() }()
 	stamp := time.Now().UTC().Format("2006-01-02")
-	rel := "raw/tunnel-candidates-" + stamp + ".md"
-	var buf strings.Builder
-	if _, err := bfs.Lstat(rel); errors.Is(err, fs.ErrNotExist) {
-		buf.WriteString("# Tunnel candidates " + stamp + "\n\nFuzzy cross-wing matches surfaced by AutoTunnel. Review and promote to a tunnel via `brain_tunnel` if relevant.\n\n")
+	path := filepath.Join(rawDir, "tunnel-candidates-"+stamp+".md")
+	existed := fileExists(path)
+	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = f.Close() }()
+	if !existed {
+		if _, err := f.WriteString("# Tunnel candidates " + stamp + "\n\nFuzzy cross-wing matches surfaced by AutoTunnel. Review and promote to a tunnel via `brain_tunnel` if relevant.\n\n"); err != nil {
+			return err
+		}
 	}
 	for _, c := range cs {
-		fmt.Fprintf(&buf, "- `%s` ↔ `%s` (term: %q)\n", sourcePath, c.TargetPath, c.MatchedTerm)
+		line := fmt.Sprintf("- `%s` ↔ `%s` (term: %q)\n", sourcePath, c.TargetPath, c.MatchedTerm)
+		if _, err := f.WriteString(line); err != nil {
+			return err
 		}
-	return bfs.AppendRegular(rel, []byte(buf.String()))
+	}
+	return nil
+}
+
+func fileExists(p string) bool {
+	_, err := os.Stat(p)
+	return err == nil
 }
 
 // WriteTunnel appends a bidirectional wikilink between sourcePath and
@@ -202,12 +197,6 @@ func logFuzzyCandidates(brainDir, sourcePath string, cs []TunnelCandidate) error
 // section headers. Rejects same-wing pairs (a tunnel is by definition
 // cross-wing) and missing notes.
 func WriteTunnel(brainDir, sourcePath, targetPath string) error {
-	if err := checkNotePath(sourcePath); err != nil {
-		return fmt.Errorf("source: %w", err)
-	}
-	if err := checkNotePath(targetPath); err != nil {
-		return fmt.Errorf("target: %w", err)
-	}
 	srcWing, err := wingOf(sourcePath)
 	if err != nil {
 		return fmt.Errorf("source: %w", err)
@@ -220,50 +209,20 @@ func WriteTunnel(brainDir, sourcePath, targetPath string) error {
 		return fmt.Errorf("tunnel must cross wings; got both in %q", srcWing)
 	}
 
-	// Both notes are read and rewritten through the brain root, regular
-	// files only: brain_tunnel passes caller-supplied paths, and the brain is
-	// a Syncthing folder that can hold symlinks.
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	srcContent, err := bfs.ReadRegular(sourcePath)
-	if err != nil {
+	srcFull := filepath.Join(brainDir, filepath.FromSlash(sourcePath))
+	tgtFull := filepath.Join(brainDir, filepath.FromSlash(targetPath))
+	if _, err := os.Stat(srcFull); err != nil {
 		return fmt.Errorf("source note: %w", err)
 	}
-	tgtContent, err := bfs.ReadRegular(targetPath)
-	if err != nil {
+	if _, err := os.Stat(tgtFull); err != nil {
 		return fmt.Errorf("target note: %w", err)
 	}
 
-	if out, changed, err := withSeeAlso(srcContent, wikilinkOf(targetPath)); err != nil {
-		return fmt.Errorf("update source: %w", err)
-	} else if changed {
-		if err := bfs.WriteRegular(sourcePath, out); err != nil {
+	if err := appendSeeAlso(srcFull, wikilinkOf(targetPath)); err != nil {
 		return fmt.Errorf("update source: %w", err)
 	}
-	}
-	if out, changed, err := withSeeAlso(tgtContent, wikilinkOf(sourcePath)); err != nil {
+	if err := appendSeeAlso(tgtFull, wikilinkOf(sourcePath)); err != nil {
 		return fmt.Errorf("update target: %w", err)
-	} else if changed {
-		if err := bfs.WriteRegular(targetPath, out); err != nil {
-			return fmt.Errorf("update target: %w", err)
-		}
-	}
-	return nil
-}
-
-// checkNotePath accepts only a clean, local wiki/<wing>/<hall>/.../<slug>.md
-// path: no "." or ".." segments, no empty segments, no leading slash.
-func checkNotePath(p string) error {
-	if p == "" || path.Clean(p) != p || !filepath.IsLocal(p) || !strings.HasSuffix(p, ".md") {
-		return fmt.Errorf("not a clean wiki note path: %q", p)
-	}
-	for _, part := range strings.Split(p, "/") {
-		if part == "" || part == "." || part == ".." {
-			return fmt.Errorf("not a clean wiki note path: %q", p)
-		}
 	}
 	return nil
 }
@@ -289,13 +248,16 @@ func wingOf(relPath string) (string, error) {
 	return parts[1], nil
 }
 
-// withSeeAlso returns content with `- [[link]]` under its See also section,
-// creating the section if absent. changed is false when the link is already
-// present.
-func withSeeAlso(content []byte, link string) (out []byte, changed bool, err error) {
+// appendSeeAlso inserts `- [[link]]` under the file's See also section,
+// creating the section if absent. No-op when the link is already present.
+func appendSeeAlso(filePath, link string) error {
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return err
+	}
 	wikilink := "[[" + link + "]]"
 	if strings.Contains(string(content), wikilink) {
-		return content, false, nil
+		return nil
 	}
 
 	bullet := "- " + wikilink
@@ -304,7 +266,8 @@ func withSeeAlso(content []byte, link string) (out []byte, changed bool, err err
 		// No section yet — append a fresh one. Always emit a trailing
 		// newline so subsequent appends don't merge into the previous line.
 		trimmed := strings.TrimRight(string(content), "\n")
-		return []byte(trimmed + "\n\n" + seeAlsoHeader + "\n\n" + bullet + "\n"), true, nil
+		out := trimmed + "\n\n" + seeAlsoHeader + "\n\n" + bullet + "\n"
+		return os.WriteFile(filePath, []byte(out), 0o644)
 	}
 
 	// Section exists — splice the bullet in just before the next `## `
@@ -330,11 +293,12 @@ func withSeeAlso(content []byte, link string) (out []byte, changed bool, err err
 		b.WriteByte('\n')
 	}
 	if err := scanner.Err(); err != nil {
-		return nil, false, err
+		return err
 	}
 	if !inserted {
 		// section was the last thing in the file — just append bullet
-		return []byte(strings.TrimRight(b.String(), "\n") + "\n" + bullet + "\n"), true, nil
+		out := strings.TrimRight(b.String(), "\n") + "\n" + bullet + "\n"
+		return os.WriteFile(filePath, []byte(out), 0o644)
 	}
-	return []byte(b.String()), true, nil
+	return os.WriteFile(filePath, []byte(b.String()), 0o644)
 }

ingestion/internal/brain/tunnel_redirect_test.go

@@ -1,38 +0,0 @@
-package brain_test
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
-)
-
-// hyperguild#173: brain_tunnel's write followed a directory symlink inside
-// wiki/ that points elsewhere in the brain.
-func TestWriteTunnelRefusesATargetBehindASymlinkedDirectory(t *testing.T) {
-	b := t.TempDir()
-	src := filepath.Join(b, "wiki", "a", "facts", "s.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(src), 0o755))
-	require.NoError(t, os.WriteFile(src, []byte("x\n"), 0o644))
-	victim := filepath.Join(b, "raw", "facts", "v.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("untouched\n"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "b"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "facts"), filepath.Join(b, "wiki", "b", "facts")))
-
-	assert.ErrorIs(t, brain.WriteTunnel(b, "wiki/a/facts/s.md", "wiki/b/facts/v.md"), brainfs.ErrNotRegular)
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "untouched\n", string(got))
-	got, _ = os.ReadFile(src)
-	assert.Equal(t, "x\n", string(got), "the source is not rewritten either")
-
-	real := filepath.Join(b, "wiki", "c", "facts", "t.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(real), 0o755))
-	require.NoError(t, os.WriteFile(real, []byte("t\n"), 0o644))
-	require.NoError(t, brain.WriteTunnel(b, "wiki/a/facts/s.md", "wiki/c/facts/t.md"), "positive control: a tunnel between real directories is written")
-}

ingestion/internal/brain/tunnel_root_test.go

@@ -1,141 +0,0 @@
-package brain_test
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
-)
-
-// brain_tunnel passes caller-supplied source and target paths to WriteTunnel,
-// which checked only "wiki/<wing>/..." and then joined them onto the brain
-// dir: ".." segments resolved outside the brain and appendSeeAlso rewrote the
-// file there.
-func TestWriteTunnelRefusesATargetThatTraversesOutOfTheBrain(t *testing.T) {
-	brain0 := t.TempDir()
-	src := filepath.Join(brain0, "wiki", "a", "facts", "s.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(src), 0o755))
-	require.NoError(t, os.WriteFile(src, []byte("---\ntitle: S\n---\nbody\n"), 0o644))
-	victim := filepath.Join(t.TempDir(), "victim.md")
-	require.NoError(t, os.WriteFile(victim, []byte("untouched\n"), 0o644))
-
-	up := strings.Repeat("../", strings.Count(filepath.Clean(brain0), "/")+3)
-	target := "wiki/b/x/" + up + strings.TrimPrefix(victim, "/")
-	err := brain.WriteTunnel(brain0, "wiki/a/facts/s.md", target)
-	assert.Error(t, err)
-	got, rerr := os.ReadFile(victim)
-	require.NoError(t, rerr)
-	assert.Equal(t, "untouched\n", string(got), "a file outside the brain was modified")
-}
-
-func TestWriteTunnelRefusesUncleanOrNonWikiPaths(t *testing.T) {
-	brain0 := t.TempDir()
-	for _, p := range []string{"wiki/a/facts/s.md", "wiki/b/facts/t.md", "wiki/b/facts/t.txt", "raw/r.md"} {
-		require.NoError(t, os.MkdirAll(filepath.Dir(filepath.Join(brain0, p)), 0o755))
-		require.NoError(t, os.WriteFile(filepath.Join(brain0, p), []byte("x\n"), 0o644))
-	}
-	for _, target := range []string{
-		"wiki/b/facts/../../../raw/r.md",
-		"wiki/b/./facts/t.md",
-		"wiki/b//facts/t.md",
-		"/wiki/b/facts/t.md",
-		"wiki/b/facts/t.txt",
-		"wiki/b/facts/",
-	} {
-		assert.Error(t, brain.WriteTunnel(brain0, "wiki/a/facts/s.md", target), target)
-	}
-	for _, p := range []string{"raw/r.md", "wiki/b/facts/t.txt"} {
-		got, err := os.ReadFile(filepath.Join(brain0, p))
-		require.NoError(t, err)
-		assert.Equal(t, "x\n", string(got), p)
-	}
-	require.NoError(t, brain.WriteTunnel(brain0, "wiki/a/facts/s.md", "wiki/b/facts/t.md"), "positive control")
-	got, err := os.ReadFile(filepath.Join(brain0, "wiki", "b", "facts", "t.md"))
-	require.NoError(t, err)
-	assert.Contains(t, string(got), "[[a/facts/s]]")
-}
-
-func TestWriteTunnelDoesNotWriteThroughASymlinkedNote(t *testing.T) {
-	brain0 := t.TempDir()
-	src := filepath.Join(brain0, "wiki", "a", "facts", "s.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(src), 0o755))
-	require.NoError(t, os.WriteFile(src, []byte("x\n"), 0o644))
-	tdir := filepath.Join(brain0, "wiki", "b", "facts")
-	require.NoError(t, os.MkdirAll(tdir, 0o755))
-	victim := filepath.Join(t.TempDir(), "victim.md")
-	require.NoError(t, os.WriteFile(victim, []byte("untouched\n"), 0o644))
-	require.NoError(t, os.Symlink(victim, filepath.Join(tdir, "t.md")))
-	assert.Error(t, brain.WriteTunnel(brain0, "wiki/a/facts/s.md", "wiki/b/facts/t.md"))
-	got, err := os.ReadFile(victim)
-	require.NoError(t, err)
-	assert.Equal(t, "untouched\n", string(got))
-
-	// The same with a link to a file elsewhere in the brain, which os.Root
-	// would follow.
-	inVictim := filepath.Join(brain0, "raw", "v.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(inVictim), 0o755))
-	require.NoError(t, os.WriteFile(inVictim, []byte("untouched\n"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "v.md"), filepath.Join(tdir, "u.md")))
-	assert.Error(t, brain.WriteTunnel(brain0, "wiki/a/facts/s.md", "wiki/b/facts/u.md"))
-	got, err = os.ReadFile(inVictim)
-	require.NoError(t, err)
-	assert.Equal(t, "untouched\n", string(got))
-	got, err = os.ReadFile(src)
-	require.NoError(t, err)
-	assert.Equal(t, "x\n", string(got), "the source is not touched when the target is refused")
-}
-
-// The target is swapped between a regular note and a symlink to an in-brain
-// file outside wiki/ while WriteTunnel runs: the read and the write each
-// refuse a symlink, so the other file is never rewritten.
-func TestWriteTunnelNeverRewritesASymlinkSwappedInForTheTarget(t *testing.T) {
-	brain0 := t.TempDir()
-	src := filepath.Join(brain0, "wiki", "a", "facts", "s.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(src), 0o755))
-	require.NoError(t, os.WriteFile(src, []byte("x\n"), 0o644))
-	tdir := filepath.Join(brain0, "wiki", "b", "facts")
-	require.NoError(t, os.MkdirAll(tdir, 0o755))
-	victim := filepath.Join(brain0, "raw", "victim.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("untouched\n"), 0o644))
-	tgt := filepath.Join(tdir, "t.md")
-	require.NoError(t, os.WriteFile(tgt, []byte("t\n"), 0o644))
-
-	var stop atomic.Bool
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		tmp := tgt + ".swap"
-		for i := 0; !stop.Load(); i++ {
-			_ = os.Remove(tmp)
-			if i%2 == 0 {
-				_ = os.WriteFile(tmp, []byte("t\n"), 0o644)
-			} else {
-				_ = os.Symlink(filepath.Join("..", "..", "..", "raw", "victim.md"), tmp)
-			}
-			_ = os.Rename(tmp, tgt)
-		}
-	}()
-	ok := 0
-	for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); {
-		if brain.WriteTunnel(brain0, "wiki/a/facts/s.md", "wiki/b/facts/t.md") == nil {
-			ok++
-		}
-		_ = os.WriteFile(src, []byte("x\n"), 0o644)
-	}
-	stop.Store(true)
-	wg.Wait()
-	got, err := os.ReadFile(victim)
-	require.NoError(t, err)
-	assert.Equal(t, "untouched\n", string(got), "the swapped-in symlink's target was rewritten")
-	assert.Positive(t, ok, "positive control: some tunnels were written to the regular target")
-}

ingestion/internal/brain/writers_redirect_test.go

@@ -1,52 +0,0 @@
-package brain_test
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
-)
-
-// hyperguild#158: BuildWingIndex wrote wiki/<wing>/_index.md with
-// os.WriteFile, so a symlinked _index.md was written through.
-func TestBuildWingIndexDoesNotWriteThroughASymlinkedIndex(t *testing.T) {
-	b := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "w", "facts"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(b, "wiki", "w", "facts", "n.md"), []byte("---\ntitle: zqn\n---\n"), 0o644))
-	victim := filepath.Join(b, "raw", "v.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("untouched"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "v.md"), filepath.Join(b, "wiki", "w", "_index.md")))
-	assert.Error(t, brain.BuildWingIndex(b, "w"))
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "untouched", string(got))
-
-	require.NoError(t, os.Remove(filepath.Join(b, "wiki", "w", "_index.md")))
-	require.NoError(t, brain.BuildWingIndex(b, "w"), "positive control")
-	idx, _ := os.ReadFile(filepath.Join(b, "wiki", "w", "_index.md"))
-	assert.Contains(t, string(idx), "zqn")
-}
-
-// AutoTunnel's fuzzy-candidate log appended to raw/tunnel-candidates-*.md
-// with os.OpenFile, so a symlinked raw/ (or log file) was written through.
-func TestAutoTunnelDoesNotAppendTheCandidateLogThroughASymlinkedRaw(t *testing.T) {
-	b := t.TempDir()
-	outside := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "a", "facts"), 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "b", "facts"), 0o755))
-	// "zq widget" matches as a substring of "zq widgets", a fuzzy candidate.
-	require.NoError(t, os.WriteFile(filepath.Join(b, "wiki", "b", "facts", "t.md"), []byte("---\ntitle: Zq Widget\n---\n"), 0o644))
-	require.NoError(t, os.Symlink(outside, filepath.Join(b, "raw")))
-	_ = brain.AutoTunnel(b, "wiki/a/facts/s.md", "about zq widgets")
-	ents, _ := os.ReadDir(outside)
-	assert.Empty(t, ents, "the candidate log was written outside the brain")
-
-	require.NoError(t, os.Remove(filepath.Join(b, "raw")))
-	require.NoError(t, brain.AutoTunnel(b, "wiki/a/facts/s.md", "about zq widgets"))
-	logs, _ := filepath.Glob(filepath.Join(b, "raw", "tunnel-candidates-*.md"))
-	assert.Len(t, logs, 1, "positive control: the fuzzy candidate is logged in the real raw/")
-}

ingestion/internal/brainfs/brainfs.go

@@ -1,456 +0,0 @@
-// Package brainfs reads the brain directory through an os.Root (hyperguild#157).
-// The brain dir is a Syncthing sendreceive folder and Syncthing syncs
-// symlinks; a reader that walks and reads by path follows a planted symlink
-// out of the brain, and blocks forever on a planted FIFO. Readers that go
-// through a Brain only ever read regular files inside the brain: os.Root
-// refuses to leave the root even if an entry is swapped mid-read, and every
-// open is non-blocking with the type checked on the opened handle.
-package brainfs
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-	"syscall"
-)
-
-// ErrNotRegular is returned for an entry that is not a regular file.
-var ErrNotRegular = errors.New("not a regular file")
-
-// ErrTooLarge is returned by ReadRegularMax for a file over the limit.
-var ErrTooLarge = errors.New("file too large")
-
-// Brain is an open brain directory.
-type Brain struct {
-	root *os.Root
-	dir  string
-}
-
-// Open opens brainDir (which may itself be a mount symlink) as a root.
-func Open(brainDir string) (*Brain, error) {
-	r, err := os.OpenRoot(brainDir)
-	if err != nil {
-		return nil, fmt.Errorf("open brain root: %w", err)
-	}
-	return &Brain{root: r, dir: brainDir}, nil
-}
-
-// Close releases the root.
-func (b *Brain) Close() error { return b.root.Close() }
-
-// Rel converts a path under the brain dir to a root-relative path.
-func (b *Brain) Rel(path string) (string, error) {
-	rel, err := filepath.Rel(b.dir, path)
-	if err != nil {
-		return "", err
-	}
-	if rel == ".." || len(rel) > 2 && rel[:3] == ".."+string(filepath.Separator) {
-		return "", fmt.Errorf("%s is outside the brain dir", path)
-	}
-	return filepath.ToSlash(rel), nil
-}
-
-// Lstat stats a brain-relative path through the root without following a
-// final symlink.
-func (b *Brain) Lstat(rel string) (fs.FileInfo, error) {
-	return b.root.Lstat(filepath.ToSlash(rel))
-}
-
-// realDir returns ErrNotRegular unless every component of rel is a real
-// directory. A swap after the check is not caught (accepted residual,
-// hyperguild#157).
-func (b *Brain) realDir(rel string) error {
-	if rel == "." {
-		return nil
-	}
-	prefix := ""
-	for _, part := range strings.Split(rel, "/") {
-		prefix = path.Join(prefix, part)
-		fi, err := b.root.Lstat(prefix)
-		if err != nil {
-			return err
-		}
-		if !fi.IsDir() {
-			return fmt.Errorf("%s: walk root component %s is not a directory: %w", rel, prefix, ErrNotRegular)
-		}
-	}
-	return nil
-}
-
-// ReadDirRegular lists the regular files directly in a brain-relative
-// directory, by name. Every component of relDir must be a real directory
-// (ErrNotRegular otherwise); symlinks, FIFOs, devices and subdirectories in
-// it are left out.
-func (b *Brain) ReadDirRegular(relDir string) ([]string, error) {
-	relDir = filepath.ToSlash(relDir)
-	if err := b.realDir(relDir); err != nil {
-		return nil, err
-	}
-	ents, err := fs.ReadDir(b.root.FS(), relDir)
-	if err != nil {
-		return nil, err
-	}
-	var names []string
-	for _, e := range ents {
-		if e.Type().IsRegular() {
-			names = append(names, e.Name())
-		}
-	}
-	return names, nil
-}
-
-// cleanRel refuses a path that is not clean and local. realDir checks the
-// cleaned parent, so the I/O must use that same path: os.Root resolves ".."
-// after following a symlink, and a ".." after a symlinked directory would
-// otherwise pass the check and redirect the read or write.
-func cleanRel(rel string) error {
-	if rel == "" || path.Clean(rel) != rel || !filepath.IsLocal(rel) || strings.Contains(rel, "\\") {
-		return fmt.Errorf("%q: not a clean brain-relative path: %w", rel, ErrNotRegular)
-	}
-	return nil
-}
-
-// ReadDirDirs lists the real subdirectories directly in a brain-relative
-// directory, by name. Every component of relDir must be a real directory
-// (ErrNotRegular otherwise); symlinks to directories are left out.
-func (b *Brain) ReadDirDirs(relDir string) ([]string, error) {
-	relDir = filepath.ToSlash(relDir)
-	if err := b.realDir(relDir); err != nil {
-		return nil, err
-	}
-	ents, err := fs.ReadDir(b.root.FS(), relDir)
-	if err != nil {
-		return nil, err
-	}
-	var names []string
-	for _, e := range ents {
-		if e.Type().IsDir() {
-			names = append(names, e.Name())
-		}
-	}
-	return names, nil
-}
-
-// PutRegular creates or replaces a regular file at a brain-relative path,
-// for creating writes (hyperguild#188, #158). Missing parent directories are
-// created one component at a time through the root, and every existing
-// component must be a real directory, so a symlinked directory cannot
-// redirect the write elsewhere in the brain or outside it. An existing file
-// is replaced only if it is regular (WriteRegular's checks); a new file is
-// created with O_EXCL and confirmed to be the file that was opened. A
-// directory swapped in after the checks is the #167 residual.
-func (b *Brain) PutRegular(rel string, data []byte) error {
-	if err := cleanRel(rel); err != nil {
-		return err
-	}
-	if err := b.mkdirReal(path.Dir(rel)); err != nil {
-		return err
-	}
-	if _, err := b.root.Lstat(rel); err == nil {
-		return b.WriteRegular(rel, data)
-	} else if !errors.Is(err, fs.ErrNotExist) {
-		return err
-	}
-	return b.createNew(rel, data)
-}
-
-// CreateRegular creates a new regular file at a brain-relative path, with
-// PutRegular's parent rules, and fails with fs.ErrExist if anything is
-// already there: for writers that must never overwrite (promote, reject).
-func (b *Brain) CreateRegular(rel string, data []byte) error {
-	if err := cleanRel(rel); err != nil {
-		return err
-	}
-	if err := b.mkdirReal(path.Dir(rel)); err != nil {
-		return err
-	}
-	return b.createNew(rel, data)
-}
-
-// createNew creates rel with O_EXCL and writes data only after confirming
-// the path is the regular file it created.
-func (b *Brain) createNew(rel string, data []byte) error {
-	f, err := b.root.OpenFile(rel, os.O_WRONLY|os.O_CREATE|os.O_EXCL|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0o644)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = f.Close() }()
-	hfi, herr := f.Stat()
-	lfi, lerr := b.root.Lstat(rel)
-	if herr != nil || lerr != nil || !lfi.Mode().IsRegular() || !os.SameFile(lfi, hfi) {
-		return fmt.Errorf("%s: changed while creating: %w", rel, ErrNotRegular)
-	}
-	if _, err := f.Write(data); err != nil {
-		return err
-	}
-	return f.Close()
-}
-
-// AppendRegular appends data to a regular file at a brain-relative path,
-// creating it (and missing parent directories, as PutRegular does) if it is
-// absent. It writes only after confirming the path is the regular file it
-// opened, so a final symlink or special file, or one swapped in, is refused.
-func (b *Brain) AppendRegular(rel string, data []byte) error {
-	if err := cleanRel(rel); err != nil {
-		return err
-	}
-	if err := b.mkdirReal(path.Dir(rel)); err != nil {
-		return err
-	}
-	if fi, err := b.root.Lstat(rel); err == nil && !fi.Mode().IsRegular() {
-		return fmt.Errorf("%s: %w", rel, ErrNotRegular)
-	} else if err != nil && !errors.Is(err, fs.ErrNotExist) {
-		return err
-	}
-	f, err := b.root.OpenFile(rel, os.O_WRONLY|os.O_APPEND|os.O_CREATE|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0o644)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = f.Close() }()
-	hfi, herr := f.Stat()
-	lfi, lerr := b.root.Lstat(rel)
-	if herr != nil || lerr != nil || !lfi.Mode().IsRegular() || !os.SameFile(lfi, hfi) {
-		return fmt.Errorf("%s: changed while opening: %w", rel, ErrNotRegular)
-	}
-	if _, err := f.Write(data); err != nil {
-		return err
-	}
-	return f.Close()
-}
-
-// Remove removes the file at a clean brain-relative path through the root,
-// refusing a path behind a symlinked directory. A final symlink is removed
-// itself, never its target.
-func (b *Brain) Remove(rel string) error {
-	if err := b.RealParent(rel); err != nil {
-		return err
-	}
-	return b.root.Remove(rel)
-}
-
-// RealParent returns ErrNotRegular unless rel is clean and every directory
-// above it is a real directory, for writers that do their own I/O (an atomic
-// rename) but must not be redirected by a symlinked directory.
-func (b *Brain) RealParent(rel string) error {
-	if err := cleanRel(rel); err != nil {
-		return err
-	}
-	return b.realDir(path.Dir(rel))
-}
-
-// mkdirReal makes sure every component of rel exists as a real directory,
-// creating missing ones through the root; an existing component that is
-// not a real directory is ErrNotRegular.
-func (b *Brain) mkdirReal(rel string) error {
-	if rel == "." {
-		return nil
-	}
-	prefix := ""
-	for _, part := range strings.Split(rel, "/") {
-		prefix = path.Join(prefix, part)
-		fi, err := b.root.Lstat(prefix)
-		if errors.Is(err, fs.ErrNotExist) {
-			if err := b.root.Mkdir(prefix, 0o755); err != nil && !errors.Is(err, fs.ErrExist) {
-				return err
-			}
-			fi, err = b.root.Lstat(prefix)
-		}
-		if err != nil {
-			return err
-		}
-		if !fi.IsDir() {
-			return fmt.Errorf("%s: component %s is not a directory: %w", rel, prefix, ErrNotRegular)
-		}
-	}
-	return nil
-}
-
-// ReadRegular reads a brain-relative path, refusing anything that is not a
-// regular file, both before the open and on the opened handle.
-func (b *Brain) ReadRegular(rel string) ([]byte, error) {
-	if err := cleanRel(rel); err != nil {
-		return nil, err
-	}
-	if err := b.realDir(path.Dir(rel)); err != nil {
-		return nil, err
-	}
-	fi, err := b.root.Lstat(rel)
-	if err != nil {
-		return nil, err
-	}
-	if !fi.Mode().IsRegular() {
-		return nil, fmt.Errorf("%s: %w", rel, ErrNotRegular)
-	}
-	return b.readOpenedMax(rel, -1, fi)
-}
-
-// readOpened opens rel non-blocking and reads it only if the OPENED handle is
-// a regular file. This is the check that matters under a race: an entry
-// swapped for a FIFO after the Lstat, with a writer holding it open, would
-// otherwise park io.ReadAll forever (PR #161 review: removing it hung search
-// after 16 iterations).
-//
-// Accepted residual, as in api/rawroot.go: a HARD link to an outside file is
-// a regular file and is read. Syncthing syncs contents, not links, so a peer
-// cannot create one; fs.protected_hardlinks=1 and the pod's secrets are on a
-// different filesystem from the brain volume, so a local caller cannot link
-// them in. Refusing Nlink > 1 is the next step if either changes.
-func (b *Brain) readOpened(rel string) ([]byte, error) { return b.readOpenedMax(rel, -1, nil) }
-
-// ReadRegularMax is ReadRegular with a size limit, checked on the opened
-// handle before reading (max < 0 means no limit).
-func (b *Brain) ReadRegularMax(rel string, max int64) ([]byte, error) {
-	if err := cleanRel(rel); err != nil {
-		return nil, err
-	}
-	if err := b.realDir(path.Dir(rel)); err != nil {
-		return nil, err
-	}
-	fi, err := b.root.Lstat(rel)
-	if err != nil {
-		return nil, err
-	}
-	if !fi.Mode().IsRegular() {
-		return nil, fmt.Errorf("%s: %w", rel, ErrNotRegular)
-	}
-	return b.readOpenedMax(rel, max, fi)
-}
-
-// readOpenedMax opens rel and reads it if the opened handle is a regular file
-// and, when lfi is set, the same file the caller Lstat-ed: os.Root follows an
-// in-root final symlink even with O_NOFOLLOW, so a symlink to another brain
-// file swapped in between the Lstat and the open is refused only here.
-func (b *Brain) readOpenedMax(rel string, max int64, lfi fs.FileInfo) ([]byte, error) {
-	f, err := b.root.OpenFile(rel, os.O_RDONLY|syscall.O_NONBLOCK, 0)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = f.Close() }()
-	hfi, err := f.Stat()
-	if err != nil {
-		return nil, err
-	}
-	if !hfi.Mode().IsRegular() {
-		return nil, fmt.Errorf("%s: %w", rel, ErrNotRegular)
-	}
-	if lfi != nil && !os.SameFile(lfi, hfi) {
-		return nil, fmt.Errorf("%s: changed while opening: %w", rel, ErrNotRegular)
-	}
-	if max >= 0 && hfi.Size() > max {
-		return nil, fmt.Errorf("%s is %d bytes (limit %d): %w", rel, hfi.Size(), max, ErrTooLarge)
-	}
-	var r io.Reader = f
-	if wrapAfterStat != nil {
-		r = wrapAfterStat(r)
-	}
-	if max < 0 {
-		return io.ReadAll(r)
-	}
-	// The handle's size can grow after the check; bound the read itself.
-	data, err := io.ReadAll(io.LimitReader(r, max+1))
-	if err != nil {
-		return nil, err
-	}
-	if int64(len(data)) > max {
-		return nil, fmt.Errorf("%s grew past %d bytes while read: %w", rel, max, ErrTooLarge)
-	}
-	return data, nil
-}
-
-// wrapAfterStat is a test seam: it runs between the size check and the read,
-// and wraps the reader the read consumes. A package global: brainfs tests
-// must not use t.Parallel.
-var wrapAfterStat func(io.Reader) io.Reader
-
-// WalkRegular walks a brain-relative directory through the root and calls fn
-// for each regular file. Directories are descended; symlinks, FIFOs and
-// devices found by the walk are skipped. A walk root with any component that
-// is not a real directory goes to onErr as ErrNotRegular and nothing is
-// yielded. An entry error is passed to onErr and the walk continues; a nil
-// onErr ignores it.
-//
-// Accepted residual (hyperguild#157): a directory swapped for a symlink
-// between the listing and the read is followed. os.Root still keeps the read
-// inside the brain, but not inside relDir.
-func (b *Brain) WalkRegular(relDir string, fn func(rel string) error, onErr func(rel string, err error)) error {
-	relDir = filepath.ToSlash(relDir)
-	// fs.WalkDir stats its root with a follow, and os.Root allows a symlink
-	// that stays inside the brain: knowledge -> . would alias the whole
-	// brain. Require every component of the root to be a real directory
-	// (Lstat checks only the last one).
-	err := b.realDir(relDir)
-	if err != nil {
-		if onErr != nil {
-			onErr(relDir, err)
-		}
-		return nil
-	}
-	return fs.WalkDir(b.root.FS(), relDir, func(p string, d fs.DirEntry, err error) error {
-		if err != nil {
-			if onErr != nil {
-				onErr(p, err)
-			}
-			if d != nil && d.IsDir() {
-				return fs.SkipDir
-			}
-			return nil
-		}
-		if d.IsDir() || !d.Type().IsRegular() {
-			return nil
-		}
-		return fn(p)
-	})
-}
-
-// WriteRegular replaces the contents of an existing regular file at a
-// brain-relative path. It never creates a file and never writes through a
-// final symlink: os.Root.OpenFile follows an in-root final symlink even with
-// O_NOFOLLOW (verified on go1.27), so the path is Lstat-ed through the root
-// first and the opened handle must be that same file (os.SameFile), which
-// also catches a swap between the two. O_NONBLOCK keeps a FIFO from blocking
-// the open. Every directory above the file must be a real directory
-// (hyperguild#173); a directory swapped in after that check is the #167
-// residual.
-func (b *Brain) WriteRegular(rel string, data []byte) error {
-	if err := cleanRel(rel); err != nil {
-		return err
-	}
-	// Every directory above the file must be real: os.Root follows an
-	// in-brain intermediate symlink, which would redirect the write
-	// elsewhere in the brain (hyperguild#173). A swap after this check is
-	// the #167 residual.
-	if err := b.realDir(path.Dir(rel)); err != nil {
-		return err
-	}
-	lfi, err := b.root.Lstat(rel)
-	if err != nil {
-		return err
-	}
-	if !lfi.Mode().IsRegular() {
-		return fmt.Errorf("%s: %w", rel, ErrNotRegular)
-	}
-	f, err := b.root.OpenFile(rel, os.O_WRONLY|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = f.Close() }()
-	fi, err := f.Stat()
-	if err != nil {
-		return err
-	}
-	if !fi.Mode().IsRegular() || !os.SameFile(lfi, fi) {
-		return fmt.Errorf("%s: changed while opening: %w", rel, ErrNotRegular)
-	}
-	if err := f.Truncate(0); err != nil {
-		return err
-	}
-	if _, err := f.Write(data); err != nil {
-		return err
-	}
-	return f.Close()
-}

ingestion/internal/brainfs/brainfs_test.go

@@ -1,531 +0,0 @@
-package brainfs
-
-import (
-	"errors"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"sync"
-	"sync/atomic"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// The handle check is what stops a FIFO swapped in after the Lstat. A FIFO
-// with no writer reads EOF at once, so a race test could not see the check
-// missing; here a writer holds the FIFO open, as any local process can, and
-// readOpened must refuse it promptly (PR #161 review).
-func TestReadOpenedRefusesAFIFOHeldOpenByAWriter(t *testing.T) {
-	dir := t.TempDir()
-	fifo := filepath.Join(dir, "p.md")
-	require.NoError(t, syscall.Mkfifo(fifo, 0o644))
-	w, err := os.OpenFile(fifo, os.O_RDWR, 0)
-	require.NoError(t, err)
-	defer func() { _ = w.Close() }()
-
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	done := make(chan error, 1)
-	go func() { _, err := b.readOpened("p.md"); done <- err }()
-	select {
-	case err := <-done:
-		assert.True(t, errors.Is(err, ErrNotRegular), "got %v", err)
-	case <-time.After(2 * time.Second):
-		t.Fatal("readOpened blocked on a FIFO with a writer")
-	}
-}
-
-func TestReadRegularRefusesSymlinksAndReadsRegularFiles(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "ok.md"), []byte("ok"), 0o644))
-	outside := filepath.Join(t.TempDir(), "s.md")
-	require.NoError(t, os.WriteFile(outside, []byte("secret"), 0o644))
-	require.NoError(t, os.Symlink(outside, filepath.Join(dir, "link.md")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	got, err := b.ReadRegular("ok.md")
-	require.NoError(t, err)
-	assert.Equal(t, "ok", string(got))
-	_, err = b.ReadRegular("link.md")
-	assert.True(t, errors.Is(err, ErrNotRegular), "got %v", err)
-	_, err = b.ReadRegular("../" + filepath.Base(outside))
-	assert.Error(t, err)
-}
-
-func TestRelAcceptsPathsInsideAndRefusesEscapes(t *testing.T) {
-	dir := t.TempDir()
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	for in, want := range map[string]string{
-		filepath.Join(dir, "wiki", "x.md"): "wiki/x.md",
-		filepath.Join(dir, "..foo", "x"):   "..foo/x",
-		dir:                                ".",
-	} {
-		got, err := b.Rel(in)
-		require.NoError(t, err, in)
-		assert.Equal(t, want, got, in)
-	}
-	for _, bad := range []string{filepath.Join(dir, "..", "x"), dir + "-evil/x", "/etc/passwd", filepath.Join(dir, "wiki", "..", "..", "x")} {
-		_, err := b.Rel(bad)
-		assert.Error(t, err, bad)
-	}
-}
-
-func TestWalkRegularYieldsOnlyRegularFiles(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "a"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "a", "n.md"), []byte("n"), 0o644))
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(dir, "a", "dirlink")))
-	require.NoError(t, os.Symlink(filepath.Join(dir, "a", "n.md"), filepath.Join(dir, "a", "filelink.md")))
-	require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "a", "p.md"), 0o644))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	var got []string
-	require.NoError(t, b.WalkRegular(".", func(rel string) error { got = append(got, rel); return nil }, nil))
-	assert.Equal(t, []string{"a/n.md"}, got)
-}
-
-func TestReadRegularMaxRefusesAFileOverTheLimit(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "big.md"), make([]byte, 100), 0o644))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	_, err = b.ReadRegularMax("big.md", 99)
-	assert.True(t, errors.Is(err, ErrTooLarge), "got %v", err)
-	got, err := b.ReadRegularMax("big.md", 100)
-	require.NoError(t, err)
-	assert.Len(t, got, 100)
-}
-
-func TestReadRegularMaxRefusesAndStopsReadingAFileThatGrowsPastTheLimit(t *testing.T) {
-	dir := t.TempDir()
-	p := filepath.Join(dir, "grow.md")
-	require.NoError(t, os.WriteFile(p, make([]byte, 10), 0o644))
-	consumed := &countingReader{}
-	wrapAfterStat = func(r io.Reader) io.Reader {
-		f, err := os.OpenFile(p, os.O_WRONLY|os.O_APPEND, 0)
-		require.NoError(t, err)
-		_, err = f.Write(make([]byte, 1000))
-		require.NoError(t, err)
-		require.NoError(t, f.Close())
-		consumed.r = r
-		return consumed
-	}
-	t.Cleanup(func() { wrapAfterStat = nil })
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	got, err := b.ReadRegularMax("grow.md", 100)
-	assert.True(t, errors.Is(err, ErrTooLarge), "got %v", err)
-	assert.Nil(t, got)
-	assert.LessOrEqual(t, consumed.n, 101, "read past max+1 bytes")
-}
-
-type countingReader struct {
-	r io.Reader
-	n int
-}
-
-func (c *countingReader) Read(p []byte) (int, error) {
-	n, err := c.r.Read(p)
-	c.n += n
-	return n, err
-}
-
-func TestLstatDoesNotFollowSymlinksAndRefusesEscapes(t *testing.T) {
-	dir := t.TempDir()
-	outside := filepath.Join(t.TempDir(), "o.md")
-	require.NoError(t, os.WriteFile(outside, []byte("o"), 0o644))
-	require.NoError(t, os.Symlink(outside, filepath.Join(dir, "l.md")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	fi, err := b.Lstat("l.md")
-	require.NoError(t, err)
-	assert.Equal(t, fs.ModeSymlink, fi.Mode().Type())
-	_, err = b.Lstat("../" + filepath.Base(filepath.Dir(outside)) + "/o.md")
-	assert.Error(t, err)
-}
-
-func TestWalkRegularReportsASymlinkedWalkRootAndYieldsNothing(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "real"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "real", "n.md"), []byte("n"), 0o644))
-	require.NoError(t, os.Symlink("real", filepath.Join(dir, "alias")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	var got []string
-	var errs []error
-	require.NoError(t, b.WalkRegular("alias", func(rel string) error { got = append(got, rel); return nil },
-		func(_ string, err error) { errs = append(errs, err) }))
-	assert.Empty(t, got)
-	require.Len(t, errs, 1)
-	assert.ErrorIs(t, errs[0], ErrNotRegular)
-}
-
-func TestWalkRegularReportsASymlinkedIntermediateComponentOfTheWalkRoot(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "real", "sub"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "real", "sub", "n.md"), []byte("n"), 0o644))
-	require.NoError(t, os.Symlink("real", filepath.Join(dir, "alias")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	var got []string
-	var errs []error
-	require.NoError(t, b.WalkRegular("alias/sub", func(rel string) error { got = append(got, rel); return nil },
-		func(_ string, err error) { errs = append(errs, err) }))
-	assert.Empty(t, got)
-	require.Len(t, errs, 1)
-	assert.ErrorIs(t, errs[0], ErrNotRegular)
-}
-
-func TestReadDirRegularListsOnlyRegularFilesAndRefusesSymlinkedComponents(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "a", "b", "sub"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "a", "b", "n.md"), []byte("n"), 0o644))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "other.md"), []byte("o"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "other.md"), filepath.Join(dir, "a", "b", "l.md")))
-	require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "a", "b", "f.md"), 0o644))
-	require.NoError(t, os.Symlink("a", filepath.Join(dir, "alias")))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "x"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "a"), filepath.Join(dir, "x", "mid")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	names, err := b.ReadDirRegular("a/b")
-	require.NoError(t, err)
-	assert.Equal(t, []string{"n.md"}, names)
-	for _, rel := range []string{"alias/b", "x/mid/b"} {
-		_, err := b.ReadDirRegular(rel)
-		assert.ErrorIs(t, err, ErrNotRegular, rel)
-	}
-}
-
-// A final component swapped for a symlink to another regular file in the
-// brain between the Lstat and the open: os.Root follows in-root links, so
-// only comparing the two (os.SameFile) refuses it.
-func TestReadRegularDoesNotReturnAnInBrainFileSwappedInBehindASymlink(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "s.md"), []byte("zqsamefilesentinel"), 0o644))
-	p := filepath.Join(dir, "r.md")
-	require.NoError(t, os.WriteFile(p, []byte("inside"), 0o644))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	var stop atomic.Bool
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		tmp := p + ".swap"
-		for i := 0; !stop.Load(); i++ {
-			_ = os.Remove(tmp)
-			if i%2 == 0 {
-				_ = os.WriteFile(tmp, []byte("inside"), 0o644)
-			} else {
-				_ = os.Symlink("s.md", tmp)
-			}
-			_ = os.Rename(tmp, p)
-		}
-	}()
-	leaks, ok := 0, 0
-	for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); {
-		got, err := b.ReadRegular("r.md")
-		if err == nil {
-			ok++
-		}
-		if string(got) == "zqsamefilesentinel" {
-			leaks++
-		}
-		got, _ = b.ReadRegularMax("r.md", 1<<20)
-		if string(got) == "zqsamefilesentinel" {
-			leaks++
-		}
-	}
-	stop.Store(true)
-	wg.Wait()
-	assert.Zero(t, leaks)
-	assert.Positive(t, ok, "positive control: the regular file is read")
-}
-
-func TestWriteRegularRefusesFinalSymlinksFIFOsEscapesAndMissingFilesAndRewritesRegularFiles(t *testing.T) {
-	dir := t.TempDir()
-	outside := filepath.Join(t.TempDir(), "o.md")
-	require.NoError(t, os.WriteFile(outside, []byte("untouched"), 0o644))
-	require.NoError(t, os.Symlink(outside, filepath.Join(dir, "l.md")))
-	require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "f.md"), 0o644))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "n.md"), []byte("old content"), 0o644))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	assert.Error(t, b.WriteRegular("l.md", []byte("x")))
-	got, _ := os.ReadFile(outside)
-	assert.Equal(t, "untouched", string(got))
-
-	// A symlink to another file inside the brain: os.Root would allow it,
-	// only O_NOFOLLOW refuses it.
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "in.md"), []byte("inside"), 0o644))
-	require.NoError(t, os.Symlink("in.md", filepath.Join(dir, "il.md")))
-	assert.Error(t, b.WriteRegular("il.md", []byte("x")))
-	got, _ = os.ReadFile(filepath.Join(dir, "in.md"))
-	assert.Equal(t, "inside", string(got))
-
-	// A reader held open, so a non-blocking write open would succeed. The
-	// Lstat type check refuses the FIFO first; the handle check and
-	// O_NONBLOCK matter only if it is swapped in after the Lstat.
-	r, err := os.OpenFile(filepath.Join(dir, "f.md"), os.O_RDONLY|syscall.O_NONBLOCK, 0)
-	require.NoError(t, err)
-	defer func() { _ = r.Close() }()
-	done := make(chan error, 1)
-	go func() { done <- b.WriteRegular("f.md", []byte("x")) }()
-	select {
-	case err := <-done:
-		assert.Error(t, err)
-	case <-time.After(3 * time.Second):
-		t.Fatal("WriteRegular hung on a FIFO")
-	}
-
-	assert.Error(t, b.WriteRegular("../"+filepath.Base(filepath.Dir(outside))+"/o.md", []byte("x")))
-	assert.Error(t, b.WriteRegular("missing.md", []byte("x")), "does not create files")
-
-	require.NoError(t, b.WriteRegular("n.md", []byte("new")))
-	got, _ = os.ReadFile(filepath.Join(dir, "n.md"))
-	assert.Equal(t, "new", string(got), "truncated and rewritten")
-}
-
-func TestReadDirDirsListsOnlyRealSubdirsAndRefusesSymlinkedComponents(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "a", "real"), 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "other"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "other"), filepath.Join(dir, "a", "linked")))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "a", "f.md"), []byte("f"), 0o644))
-	require.NoError(t, os.Symlink("a", filepath.Join(dir, "alias")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	names, err := b.ReadDirDirs("a")
-	require.NoError(t, err)
-	assert.Equal(t, []string{"real"}, names)
-	_, err = b.ReadDirDirs("alias")
-	assert.ErrorIs(t, err, ErrNotRegular)
-}
-
-// hyperguild#173: a file reached through a symlinked directory inside the
-// brain is refused for reads and writes, so a caller-supplied path cannot be
-// redirected to another part of the brain.
-func TestReadAndWriteRegularRefuseAFileBehindASymlinkedDirectory(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "v.md"), []byte("untouched"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(dir, "wiki", "alias")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	_, err = b.ReadRegular("wiki/alias/v.md")
-	assert.ErrorIs(t, err, ErrNotRegular)
-	_, err = b.ReadRegularMax("wiki/alias/v.md", 100)
-	assert.ErrorIs(t, err, ErrNotRegular)
-	assert.ErrorIs(t, b.WriteRegular("wiki/alias/v.md", []byte("x")), ErrNotRegular)
-	got, _ := os.ReadFile(filepath.Join(dir, "raw", "v.md"))
-	assert.Equal(t, "untouched", string(got))
-	got, err = b.ReadRegular("raw/v.md")
-	require.NoError(t, err, "positive control: the real path still reads")
-	assert.Equal(t, "untouched", string(got))
-}
-
-// realDir checks the cleaned parent, so the I/O must use that same clean
-// path: os.Root resolves ".." after following a symlink, and a ".." placed
-// after a symlinked directory would otherwise pass the check and redirect.
-func TestReadAndWriteRegularRefuseAPathThatIsNotClean(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw", "facts"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "v.md"), []byte("untouched"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw", "facts"), filepath.Join(dir, "wiki", "alias")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	for _, rel := range []string{"wiki/alias/../v.md", "./raw/v.md", "raw//v.md", "/raw/v.md"} {
-		got, err := b.ReadRegular(rel)
-		assert.ErrorIs(t, err, ErrNotRegular, rel)
-		assert.NotContains(t, string(got), "untouched", rel)
-		_, err = b.ReadRegularMax(rel, 100)
-		assert.ErrorIs(t, err, ErrNotRegular, rel)
-		assert.ErrorIs(t, b.WriteRegular(rel, []byte("OVERWRITTEN")), ErrNotRegular, rel)
-	}
-	got, _ := os.ReadFile(filepath.Join(dir, "raw", "v.md"))
-	assert.Equal(t, "untouched", string(got))
-}
-
-// hyperguild#188: PutRegular creates or replaces a regular file through the
-// root. Missing parent directories are created; an existing component that
-// is not a real directory, a final symlink or special file, and an unclean
-// path are refused, and nothing is created at a link's target.
-func TestPutRegularCreatesOrReplacesOnlyThroughRealDirectories(t *testing.T) {
-	dir := t.TempDir()
-	outside := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw"), 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(dir, "wiki", "inwing")))
-	require.NoError(t, os.Symlink(outside, filepath.Join(dir, "wiki", "outwing")))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "v.md"), []byte("untouched"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki", "w"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "v.md"), filepath.Join(dir, "wiki", "w", "link.md")))
-	require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "wiki", "w", "f.md"), 0o644))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	for _, rel := range []string{"wiki/inwing/facts/n.md", "wiki/outwing/facts/n.md", "wiki/w/link.md", "wiki/w/f.md", "wiki/w/../../raw/v.md", "/abs.md"} {
-		assert.ErrorIs(t, b.PutRegular(rel, []byte("x")), ErrNotRegular, rel)
-	}
-	ents, _ := os.ReadDir(outside)
-	assert.Empty(t, ents, "nothing created outside the brain")
-	_, err = os.Stat(filepath.Join(dir, "raw", "facts"))
-	assert.True(t, os.IsNotExist(err), "nothing created through the in-brain link")
-	got, _ := os.ReadFile(filepath.Join(dir, "raw", "v.md"))
-	assert.Equal(t, "untouched", string(got))
-
-	require.NoError(t, b.PutRegular("wiki/new/facts/n.md", []byte("one")), "positive control: create with missing parents")
-	got, _ = os.ReadFile(filepath.Join(dir, "wiki", "new", "facts", "n.md"))
-	assert.Equal(t, "one", string(got))
-	require.NoError(t, b.PutRegular("wiki/new/facts/n.md", []byte("two")), "positive control: replace")
-	got, _ = os.ReadFile(filepath.Join(dir, "wiki", "new", "facts", "n.md"))
-	assert.Equal(t, "two", string(got))
-}
-
-func TestAppendRegularCreatesOrAppendsOnlyThroughRealDirectories(t *testing.T) {
-	dir := t.TempDir()
-	outside := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "v.md"), []byte("untouched"), 0o644))
-	require.NoError(t, os.Symlink(outside, filepath.Join(dir, "outdir")))
-	require.NoError(t, os.Symlink("raw", filepath.Join(dir, "indir")))
-	require.NoError(t, os.Symlink(filepath.Join("raw", "v.md"), filepath.Join(dir, "log.md")))
-	require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "f.md"), 0o644))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	for _, rel := range []string{"outdir/l.md", "indir/v.md", "log.md", "f.md", "raw/../log.md"} {
-		assert.ErrorIs(t, b.AppendRegular(rel, []byte("x")), ErrNotRegular, rel)
-	}
-	ents, _ := os.ReadDir(outside)
-	assert.Empty(t, ents)
-	got, _ := os.ReadFile(filepath.Join(dir, "raw", "v.md"))
-	assert.Equal(t, "untouched", string(got))
-
-	require.NoError(t, b.AppendRegular("logs/a.md", []byte("one\n")), "positive control: create")
-	require.NoError(t, b.AppendRegular("logs/a.md", []byte("two\n")), "positive control: append")
-	got, _ = os.ReadFile(filepath.Join(dir, "logs", "a.md"))
-	assert.Equal(t, "one\ntwo\n", string(got))
-}
-
-func TestRealParentRefusesASymlinkedDirectoryOrUncleanPath(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw"), 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(dir, "wiki", "alias")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	assert.ErrorIs(t, b.RealParent("wiki/alias/x.md"), ErrNotRegular)
-	assert.ErrorIs(t, b.RealParent("wiki/../raw/x.md"), ErrNotRegular)
-	assert.NoError(t, b.RealParent("wiki/x.md"), "positive control")
-}
-
-// cleanRel must refuse an unclean path on its own: here the ".." resolves,
-// after a symlinked directory, to a real regular file, so only the clean
-// check stands between the call and that file.
-func TestAppendRegularRefusesAnUncleanPathThatResolvesToARealFile(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw", "keep"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "v.md"), []byte("untouched"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("raw", "keep"), filepath.Join(dir, "indir")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-	assert.ErrorIs(t, b.AppendRegular("indir/../v.md", []byte("x")), ErrNotRegular)
-	assert.ErrorIs(t, b.PutRegular("indir/../v.md", []byte("x")), ErrNotRegular)
-	got, _ := os.ReadFile(filepath.Join(dir, "raw", "v.md"))
-	assert.Equal(t, "untouched", string(got))
-}
-
-func TestRemoveRefusesAPathBehindASymlinkedDirectoryAndRemovesOnlyTheLink(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "v.md"), []byte("keep"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(dir, "wiki", "alias")))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw", "v.md"), filepath.Join(dir, "wiki", "link.md")))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "wiki", "n.md"), []byte("n"), 0o644))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	assert.ErrorIs(t, b.Remove("wiki/alias/v.md"), ErrNotRegular)
-	_, err = os.Stat(filepath.Join(dir, "raw", "v.md"))
-	assert.NoError(t, err, "the file behind the symlinked directory is kept")
-	require.NoError(t, b.Remove("wiki/link.md"))
-	_, err = os.Stat(filepath.Join(dir, "raw", "v.md"))
-	assert.NoError(t, err, "removing a final symlink never removes its target")
-	require.NoError(t, b.Remove("wiki/n.md"), "positive control")
-	_, err = os.Stat(filepath.Join(dir, "wiki", "n.md"))
-	assert.True(t, os.IsNotExist(err))
-}
-
-// CreateRegular is the only write path for promote and reject: it creates
-// missing parents through the root, refuses an in-brain symlinked parent and
-// an unclean path, and never replaces anything already there (fs.ErrExist,
-// content unchanged), including a dangling link.
-func TestCreateRegularCreatesOnlyNewFilesThroughRealDirectories(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "raw", "keep"), 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(dir, "wiki", "inwing")))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "raw", "v.md"), []byte("untouched"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("raw", "keep"), filepath.Join(dir, "indir")))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "wiki", "exists.md"), []byte("original"), 0o644))
-	require.NoError(t, os.Symlink("nowhere.md", filepath.Join(dir, "wiki", "dangling.md")))
-	b, err := Open(dir)
-	require.NoError(t, err)
-	defer func() { _ = b.Close() }()
-
-	assert.ErrorIs(t, b.CreateRegular("wiki/inwing/facts/n.md", []byte("x")), ErrNotRegular)
-	_, err = os.Stat(filepath.Join(dir, "raw", "facts"))
-	assert.True(t, os.IsNotExist(err), "nothing created through the in-brain link")
-	assert.ErrorIs(t, b.CreateRegular("indir/../v.md", []byte("x")), ErrNotRegular)
-	got, _ := os.ReadFile(filepath.Join(dir, "raw", "v.md"))
-	assert.Equal(t, "untouched", string(got))
-
-	assert.ErrorIs(t, b.CreateRegular("wiki/exists.md", []byte("x")), fs.ErrExist)
-	got, _ = os.ReadFile(filepath.Join(dir, "wiki", "exists.md"))
-	assert.Equal(t, "original", string(got))
-	assert.ErrorIs(t, b.CreateRegular("wiki/dangling.md", []byte("x")), fs.ErrExist)
-	_, err = os.Stat(filepath.Join(dir, "wiki", "nowhere.md"))
-	assert.True(t, os.IsNotExist(err), "nothing created at the dangling link's target")
-
-	require.NoError(t, b.CreateRegular("wiki/new/facts/n.md", []byte("one")), "positive control: create with missing parents")
-	got, _ = os.ReadFile(filepath.Join(dir, "wiki", "new", "facts", "n.md"))
-	assert.Equal(t, "one", string(got))
-}

ingestion/internal/brainfs/brainfstest/brainfstest.go

@@ -1,173 +0,0 @@
-// Package brainfstest is the shared harness for hyperguild#157's swap-race
-// tests: it keeps swapping a regular note, a symlink to a sentinel target file
-// (outside the brain, or inside it for hyperguild#171), or a FIFO (with a
-// writer held open) into a path while a reader under test loops.
-// It observes two things, over a sampled window only: no sentinel byte from
-// the target reaches the reader's output, and the reader returns within a
-// timeout. It does not cover
-// hard links, other paths into the reader, or races it does not generate.
-package brainfstest
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"syscall"
-	"testing"
-	"time"
-)
-
-// Sentinel marks the target file's contents.
-const Sentinel = "zqbrainfssentinelonefiftyseven"
-
-// outsideContent carries Sentinel in every field a reader might extract: the
-// frontmatter title and aliases, a heading, a wikilink and the body.
-const outsideContent = "---\ntitle: " + Sentinel + "\naliases:\n  - " + Sentinel + "\n---\n# " + Sentinel +
-	"\n\n" + Sentinel + " [[" + Sentinel + "]]\n"
-
-// Outside writes a file outside any brain dir containing Sentinel.
-func Outside(t testing.TB) string {
-	t.Helper()
-	p := filepath.Join(t.TempDir(), "secret.md")
-	if err := os.WriteFile(p, []byte(outsideContent), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	return p
-}
-
-var swapSeq atomic.Int64
-
-// StartSwap renames, in a loop, a regular note (content inside) and either
-// a symlink to outside or a FIFO into path, until the test ends. FIFOs get a
-// writer held open until the swapper exits, so a reader that skips the
-// handle check parks forever instead of reading EOF. The swapper is stopped
-// and awaited before t.TempDir cleanup. It returns the number of symlinks
-// or FIFOs actually renamed into path so far, so a caller can tell a race
-// that ran from one whose every swap failed (hyperguild#177).
-func StartSwap(t testing.TB, path, inside, outside string, fifo bool) *atomic.Int64 {
-	t.Helper()
-	var swaps atomic.Int64
-	var stop atomic.Bool
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		// A name of its own: swappers on one path share a test, and one
-		// opening another's FIFO for write would block forever.
-		tmp := fmt.Sprintf("%s.swap%d", path, swapSeq.Add(1))
-		// A relative link: os.Root refuses every absolute link on its own, so
-		// an absolute in-brain target would test nothing.
-		link := outside
-		if rel, err := filepath.Rel(filepath.Dir(path), outside); err == nil {
-			link = rel
-		}
-		var writers []*os.File
-		defer func() {
-			for _, w := range writers {
-				_ = w.Close()
-			}
-		}()
-		for i := 0; !stop.Load(); i++ {
-			_ = os.Remove(tmp)
-			var made error
-			switch {
-			case i%2 == 0:
-				_ = os.WriteFile(tmp, []byte(inside), 0o644)
-			case fifo:
-				if made = syscall.Mkfifo(tmp, 0o644); made == nil {
-					if w, err := os.OpenFile(tmp, os.O_RDWR, 0); err == nil {
-						writers = append(writers, w)
-					}
-				}
-			default:
-				made = os.Symlink(link, tmp)
-			}
-			if err := os.Rename(tmp, path); err == nil && made == nil && i%2 == 1 {
-				swaps.Add(1)
-			}
-		}
-	}()
-	t.Cleanup(func() { stop.Store(true); wg.Wait() })
-	return &swaps
-}
-
-// WriteSentinelAt writes a file carrying Sentinel at p (creating its
-// directory), for an in-brain symlink target.
-func WriteSentinelAt(t *testing.T, p string) string {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(p, []byte(outsideContent), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	return p
-}
-
-// AssertNoLeak loops read for d while a symlink swapper runs on path, and
-// fails if any output contains Sentinel. The symlink points outside the
-// brain; os.Root refuses that on its own, so pair it with AssertNoLeakFrom
-// and an in-brain target.
-func AssertNoLeak(t *testing.T, path, inside string, d time.Duration, read func() string) {
-	t.Helper()
-	AssertNoLeakFrom(t, path, inside, Outside(t), d, read)
-}
-
-// InsideMarker must appear in the inside note's content and in read's
-// output whenever read saw that note: the floor below counts such reads.
-const InsideMarker = "inside"
-
-// AssertNoLeakFrom is AssertNoLeak with the symlink pointing at target, e.g.
-// a file elsewhere in the brain written with WriteSentinelAt.
-//
-// Beyond "no Sentinel in any output" it sets two floors, because without
-// them the assertion passes when nothing was tested (hyperguild#177): at
-// least one symlink must have been swapped into path, and at least one read
-// must have returned InsideMarker (a reader that always errors returns
-// nothing, and so never leaks).
-func AssertNoLeakFrom(t testing.TB, path, inside, target string, d time.Duration, read func() string) {
-	t.Helper()
-	if !strings.Contains(inside, InsideMarker) {
-		t.Fatalf("inside content must contain %q", InsideMarker)
-	}
-	swaps := StartSwap(t, path, inside, target, false)
-	leaks, iters, insideReads := 0, 0, 0
-	for deadline := time.Now().Add(d); time.Now().Before(deadline); iters++ {
-		out := read()
-		leaks += strings.Count(out, Sentinel)
-		if strings.Contains(out, InsideMarker) {
-			insideReads++
-		}
-	}
-	if leaks > 0 {
-		t.Fatalf("symlink target %s leaked %d times in %d iterations", target, leaks, iters)
-	}
-	if n := swaps.Load(); n == 0 {
-		t.Fatalf("no symlink was swapped into %s in %d iterations: the race did not run", path, iters)
-	}
-	if insideReads == 0 {
-		t.Fatalf("no read in %d iterations returned the inside note (%q): the reader read nothing", iters, InsideMarker)
-	}
-}
-
-// AssertNoHang loops read for d while a FIFO swapper (held writers) runs on
-// path, and fails if a read does not return within timeout.
-func AssertNoHang(t *testing.T, path, inside string, d, timeout time.Duration, read func()) {
-	t.Helper()
-	StartSwap(t, path, inside, Outside(t), true)
-	done := make(chan struct{})
-	go func() {
-		for deadline := time.Now().Add(d); time.Now().Before(deadline); {
-			read()
-		}
-		close(done)
-	}()
-	select {
-	case <-done:
-	case <-time.After(timeout):
-		t.Fatal("reader hung on a swapped-in FIFO with a writer held open")
-	}
-}

ingestion/internal/brainfs/brainfstest/brainfstest_test.go

@@ -1,79 +0,0 @@
-package brainfstest
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"syscall"
-	"testing"
-	"time"
-)
-
-// recordingTB stands in for the test under AssertNoLeakFrom so a fatal
-// there can be observed instead of failing this test. Fatalf ends the
-// calling goroutine the way testing.T does.
-type recordingTB struct {
-	testing.TB
-	failed bool
-	msg    string
-}
-
-func (r *recordingTB) Fatalf(format string, args ...any) {
-	r.failed, r.msg = true, fmt.Sprintf(format, args...)
-	runtime.Goexit()
-}
-
-func runAssert(t *testing.T, path, target string, read func() string) *recordingTB {
-	t.Helper()
-	r := &recordingTB{TB: t}
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		AssertNoLeakFrom(r, path, "inside", target, 200*time.Millisecond, read)
-	}()
-	<-done
-	return r
-}
-
-// hyperguild#177: with every swap failing, no leak can occur, so the leak
-// assertion passed without testing anything.
-func TestAssertNoLeakFromFailsWhenNoSymlinkSwapSucceeds(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "missing-dir", "r.md")
-	r := runAssert(t, path, Outside(t), func() string { return "inside" })
-	if !r.failed {
-		t.Fatal("AssertNoLeakFrom passed with zero successful symlink swaps")
-	}
-}
-
-// hyperguild#177: a reader that always errors returns nothing, so it never
-// leaks either.
-func TestAssertNoLeakFromFailsWhenNoReadReturnsTheInsideNote(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "r.md")
-	r := runAssert(t, path, Outside(t), func() string { return "" })
-	if !r.failed {
-		t.Fatal("AssertNoLeakFrom passed with zero reads returning the inside note")
-	}
-}
-
-// Positive control: a reader that refuses symlinks and reads regular files
-// passes, so the floors do not fail a working reader.
-func TestAssertNoLeakFromPassesAReaderThatRefusesSymlinks(t *testing.T) {
-	path := filepath.Join(t.TempDir(), "r.md")
-	read := func() string {
-		f, err := os.OpenFile(path, os.O_RDONLY|noFollow, 0)
-		if err != nil {
-			return ""
-		}
-		defer func() { _ = f.Close() }()
-		b := make([]byte, 64)
-		n, _ := f.Read(b)
-		return string(b[:n])
-	}
-	r := runAssert(t, path, Outside(t), read)
-	if r.failed {
-		t.Fatalf("a symlink-refusing reader failed: %s", r.msg)
-	}
-}
-
-const noFollow = syscall.O_NOFOLLOW

ingestion/internal/classification/classification.go

@@ -16,10 +16,9 @@
 package classification
 
 import (
-	"errors"
 	"fmt"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
-	"io/fs"
+	"os"
+	"path/filepath"
 	"strings"
 
 	"gopkg.in/yaml.v3"
@@ -111,20 +110,9 @@ type rawConfig struct {
 func Load(brainDir string) (*Config, error) {
 	cfg := &Config{wings: map[string]Level{}, repos: map[string]Level{}}
 
-	// Read through the brain root, regular files only (hyperguild#157): a
-	// symlinked or special file is not trusted as the config, which is a hard
-	// error like a malformed one.
-	bfs, err := brainfs.Open(brainDir)
-	if errors.Is(err, fs.ErrNotExist) {
-		return cfg, nil
-	}
+	data, err := os.ReadFile(filepath.Join(brainDir, "classification.yaml"))
 	if err != nil {
-		return nil, fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	data, err := bfs.ReadRegular("classification.yaml")
-	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
+		if os.IsNotExist(err) {
 			return cfg, nil
 		}
 		return nil, fmt.Errorf("read classification.yaml: %w", err)

ingestion/internal/classification/root_test.go

@@ -1,46 +0,0 @@
-package classification
-
-import (
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// hyperguild#157 slice 6: Load read classification.yaml with os.ReadFile. It
-// sets the I1 sovereignty levels; a symlinked file must not be trusted as the
-// config (a hard error, as for a malformed file), and a FIFO must not hang
-// startup.
-func TestLoadRefusesASymlinkedOrFIFOClassificationFile(t *testing.T) {
-	ok := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(ok, "classification.yaml"), []byte("wings:\n  w: confidential\n"), 0o644))
-	_, err := Load(ok)
-	require.NoError(t, err, "positive control")
-
-	linked := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(linked, "real.yaml"), []byte("wings:\n  w: public\n"), 0o644))
-	require.NoError(t, os.Symlink("real.yaml", filepath.Join(linked, "classification.yaml")))
-	_, err = Load(linked)
-	assert.Error(t, err, "an in-brain symlink is not trusted as the config")
-
-	fifo := t.TempDir()
-	require.NoError(t, syscall.Mkfifo(filepath.Join(fifo, "classification.yaml"), 0o644))
-	w, err := os.OpenFile(filepath.Join(fifo, "classification.yaml"), os.O_RDWR, 0)
-	require.NoError(t, err)
-	defer func() { _ = w.Close() }()
-	done := make(chan error, 1)
-	go func() { _, err := Load(fifo); done <- err }()
-	select {
-	case err := <-done:
-		assert.Error(t, err)
-	case <-time.After(3 * time.Second):
-		t.Fatal("Load hung on a FIFO")
-	}
-
-	_, err = Load(t.TempDir())
-	assert.NoError(t, err, "an absent file is still not an error")
-}

ingestion/internal/extract/callsites_test.go

@@ -1,130 +0,0 @@
-package extract
-
-import (
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-)
-
-const extractPkg = "github.com/mathiasbq/hyperguild/ingestion/internal/extract"
-
-// parseNonTest parses every non-test Go file under the module.
-func parseNonTest(t *testing.T) map[string]*ast.File {
-	t.Helper()
-	fset := token.NewFileSet()
-	out := map[string]*ast.File{}
-	err := filepath.WalkDir(filepath.Join("..", ".."), func(p string, d os.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		if d.IsDir() && (d.Name() == "vendor" || d.Name() == ".git") {
-			return filepath.SkipDir
-		}
-		if d.IsDir() || !strings.HasSuffix(p, ".go") || strings.HasSuffix(p, "_test.go") {
-			return nil
-		}
-		f, perr := parser.ParseFile(fset, p, nil, 0)
-		if perr != nil {
-			return perr
-		}
-		out[filepath.ToSlash(p)] = f
-		return nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	return out
-}
-
-// PR #156 review: reading a caller-chosen path by name reopens it after the
-// containment check (hyperguild#153 item 3). Outside this package, nothing
-// may reference extract.Text — called OR taken as a value — under whatever
-// name the package is imported (round 2: an alias and a func value slipped
-// past a plain text search).
-func TestNoPackageReferencesExtractTextOutsideExtract(t *testing.T) {
-	for path, f := range parseNonTest(t) {
-		if strings.Contains(path, "internal/extract/") {
-			continue
-		}
-		names := map[string]bool{}
-		for _, imp := range f.Imports {
-			if p, _ := strconv.Unquote(imp.Path.Value); p == extractPkg {
-				name := "extract"
-				if imp.Name != nil {
-					name = imp.Name.Name
-				}
-				if name == "." {
-					t.Errorf("%s dot-imports extract; import it by name so its use stays checkable", path)
-				}
-				names[name] = true
-			}
-		}
-		if len(names) == 0 {
-			continue
-		}
-		ast.Inspect(f, func(n ast.Node) bool {
-			if sel, ok := n.(*ast.SelectorExpr); ok {
-				if id, ok := sel.X.(*ast.Ident); ok && names[id.Name] && sel.Sel.Name == "Text" {
-					t.Errorf("%s references %s.Text; use extract.TextIn through an os.Root", path, id.Name)
-				}
-			}
-			return true
-		})
-	}
-}
-
-// PR #156 review round 2: the FIFO fix (open non-blocking, check the handle)
-// lives in OpenRegular, and reverting any caller to a plain Root.Open stayed
-// green. In the three raw/ reader FILES parsed below (and only those: a
-// wrapper in another file is not seen), no Open/OpenFile/ReadFile selector
-// may appear outside OpenRegular, called or taken as a method value. This is
-// a second layer; the behavioural race tests in internal/api and
-// internal/watcher are what catch a rewrite through any API (round 3).
-// osOpenAllowed names the functions in guarded files that may call os.Open*
-// on a path that is not a raw/ read.
-var osOpenAllowed = map[string]bool{
-	"internal/watcher/watcher.go:appendWatcherLog": true, // ingest log append, not a raw/ read
-	// Text reads by path; outside this package only TextIn's temp copy reaches
-	// it (TestNoPackageReferencesExtractTextOutsideExtract enforces that).
-	"internal/extract/extract.go:Text": true,
-}
-
-func TestRawReaderFilesUseNoOpenOrReadFileOutsideOpenRegular(t *testing.T) {
-	guarded := []string{"internal/api/rawroot.go", "internal/extract/extract.go", "internal/watcher/watcher.go"}
-	files := parseNonTest(t)
-	for _, g := range guarded {
-		var f *ast.File
-		for p, af := range files {
-			if strings.HasSuffix(p, g) {
-				f = af
-			}
-		}
-		if f == nil {
-			t.Fatalf("guarded file %s not found", g)
-		}
-		for _, decl := range f.Decls {
-			fn, ok := decl.(*ast.FuncDecl)
-			if !ok || fn.Name.Name == "OpenRegular" {
-				continue
-			}
-			ast.Inspect(fn, func(n ast.Node) bool {
-				sel, ok := n.(*ast.SelectorExpr)
-				if !ok {
-					return true
-				}
-				if sel.Sel.Name == "Open" || sel.Sel.Name == "OpenFile" || sel.Sel.Name == "ReadFile" {
-					if id, ok := sel.X.(*ast.Ident); ok && id.Name == "os" && osOpenAllowed[g+":"+fn.Name.Name] {
-						return true // a named non-raw write (the ingest log append)
-					}
-					t.Errorf("%s: %s calls .%s; raw/ reads must go through OpenRegular", g, fn.Name.Name, sel.Sel.Name)
-				}
-				return true
-			})
-		}
-	}
-}

ingestion/internal/extract/extract.go

@@ -3,10 +3,8 @@ package extract
 
 import (
 	"fmt"
-	"io"
 	"os"
 	"strings"
-	"syscall"
 )
 
 // Text reads the file at path and returns its plain-text content.
@@ -43,70 +41,3 @@ func fileExt(path string) string {
 	}
 	return ""
 }
-
-// TextIn is Text for a file read through an os.Root (hyperguild#153): the
-// read cannot leave the root, so a path checked earlier cannot be swapped
-// for a symlink pointing elsewhere before it is read. Formats that need an
-// external tool (pdf, docmark) are copied to a temp file from the handle
-// opened through the root, then extracted from the copy.
-func TextIn(r *os.Root, rel string) (string, error) {
-	fi, err := r.Lstat(rel)
-	if err != nil {
-		return "", fmt.Errorf("stat %s: %w", rel, err)
-	}
-	if !fi.Mode().IsRegular() {
-		return "", fmt.Errorf("%s: not a regular file", rel)
-	}
-	f, _, err := OpenRegular(r, rel)
-	if err != nil {
-		return "", fmt.Errorf("open %s: %w", rel, err)
-	}
-	defer func() { _ = f.Close() }()
-	ext := strings.ToLower(fileExt(rel))
-	switch ext {
-	case ".md", ".txt":
-		b, err := io.ReadAll(f)
-		if err != nil {
-			return "", fmt.Errorf("read %s: %w", rel, err)
-		}
-		return string(b), nil
-	case ".pdf", ".docx", ".xlsx", ".pptx", ".png", ".jpg", ".jpeg":
-		tmp, err := os.CreateTemp("", "ingest-*"+ext)
-		if err != nil {
-			return "", fmt.Errorf("temp copy: %w", err)
-		}
-		defer func() { _ = os.Remove(tmp.Name()) }()
-		if _, err := io.Copy(tmp, f); err != nil {
-			_ = tmp.Close()
-			return "", fmt.Errorf("copy %s: %w", rel, err)
-		}
-		if err := tmp.Close(); err != nil {
-			return "", fmt.Errorf("copy %s: %w", rel, err)
-		}
-		return Text(tmp.Name())
-	default:
-		return "", fmt.Errorf("unsupported file extension: %s", ext)
-	}
-}
-
-// OpenRegular opens rel inside r and returns it only if the OPENED handle is
-// a regular file. The open is non-blocking, so a FIFO swapped in after an
-// Lstat (PR #156 review: it hung open(2) forever) is refused promptly rather
-// than stalling the reader. Callers keep their Lstat check, which refuses
-// symlinks outright; this closes the race between that check and the open.
-func OpenRegular(r *os.Root, rel string) (*os.File, os.FileInfo, error) {
-	f, err := r.OpenFile(rel, os.O_RDONLY|syscall.O_NONBLOCK, 0)
-	if err != nil {
-		return nil, nil, err
-	}
-	fi, err := f.Stat()
-	if err != nil {
-		_ = f.Close()
-		return nil, nil, err
-	}
-	if !fi.Mode().IsRegular() {
-		_ = f.Close()
-		return nil, nil, fmt.Errorf("%s: not a regular file", rel)
-	}
-	return f, fi, nil
-}

ingestion/internal/extract/root_test.go

@@ -1,64 +0,0 @@
-package extract
-
-import (
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// hyperguild#153 item 3: ingest checked a path, then extract.Text reopened it
-// by name, so a file swapped for a symlink in between was followed out of
-// raw/. TextIn reads through an os.Root, which refuses to leave the root.
-func TestTextInReadsInsideTheRootAndRefusesEscapes(t *testing.T) {
-	root := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(root, "ok.md"), []byte("inside"), 0o644))
-	outside := filepath.Join(t.TempDir(), "secret.md")
-	require.NoError(t, os.WriteFile(outside, []byte("SENTINEL-153-TEXTIN"), 0o644))
-	require.NoError(t, os.Symlink(outside, filepath.Join(root, "leak.md")))
-
-	r, err := os.OpenRoot(root)
-	require.NoError(t, err)
-	defer func() { _ = r.Close() }()
-
-	got, err := TextIn(r, "ok.md")
-	require.NoError(t, err)
-	assert.Equal(t, "inside", got)
-
-	got, err = TextIn(r, "leak.md")
-	assert.Error(t, err)
-	assert.NotContains(t, got, "SENTINEL-153-TEXTIN")
-
-	_, err = TextIn(r, "../"+filepath.Base(outside))
-	assert.Error(t, err)
-}
-
-// PR #156 review: a regular file swapped for a FIFO between Lstat and Open
-// blocked open(2) forever. OpenRegular opens non-blocking and checks the type
-// on the opened handle, so a FIFO is refused promptly instead of hanging.
-func TestOpenRegularRefusesAFIFOWithoutBlocking(t *testing.T) {
-	dir := t.TempDir()
-	require.NoError(t, syscall.Mkfifo(filepath.Join(dir, "pipe.md"), 0o644))
-	r, err := os.OpenRoot(dir)
-	require.NoError(t, err)
-	defer func() { _ = r.Close() }()
-
-	done := make(chan error, 1)
-	go func() {
-		f, _, err := OpenRegular(r, "pipe.md")
-		if f != nil {
-			_ = f.Close()
-		}
-		done <- err
-	}()
-	select {
-	case err := <-done:
-		assert.Error(t, err)
-	case <-time.After(2 * time.Second):
-		t.Fatal("OpenRegular blocked on a FIFO")
-	}
-}

ingestion/internal/graphsync/graphsync.go

@@ -12,14 +12,10 @@ package graphsync
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"io/fs"
-	"path"
+	"os"
 	"path/filepath"
-	"strings"
 
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/graph"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/graphstore"
 )
@@ -50,25 +46,8 @@ func IndexDoc(ctx context.Context, store Store, brainDir, relPath string) error
 	if relPath == "" {
 		return nil
 	}
-	// Callers pass caller-supplied paths (brain_tunnel, brain_update): index
-	// only a clean path under wiki/ or knowledge/.
-	if path.Clean(relPath) != relPath || !filepath.IsLocal(relPath) ||
-		(!strings.HasPrefix(relPath, "wiki/") && !strings.HasPrefix(relPath, "knowledge/")) {
-		return fmt.Errorf("index %q: not a clean wiki/ or knowledge/ path", relPath)
-	}
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	return indexDoc(ctx, store, bfs, relPath)
-}
-
-// indexDoc reads relPath through the brain root, regular files only
-// (hyperguild#157): the brain is a Syncthing folder, and os.ReadFile
-// followed a synced symlink into the graph and blocked on a FIFO.
-func indexDoc(ctx context.Context, store Store, bfs *brainfs.Brain, relPath string) error {
-	content, err := bfs.ReadRegular(relPath)
+	abs := filepath.Join(brainDir, filepath.FromSlash(relPath))
+	content, err := os.ReadFile(abs)
 	if err != nil {
 		return fmt.Errorf("read %q: %w", relPath, err)
 	}
@@ -98,34 +77,33 @@ func BackfillFromBrainDir(ctx context.Context, store Store, brainDir string) (in
 	if store == nil {
 		return 0, nil
 	}
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return 0, fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	for _, root := range []string{"wiki", "knowledge"} {
-		if _, err := bfs.Lstat(root); errors.Is(err, fs.ErrNotExist) {
+	roots := []string{"wiki", "knowledge"}
+	for _, root := range roots {
+		base := filepath.Join(brainDir, root)
+		if _, err := os.Stat(base); os.IsNotExist(err) {
 			continue
 		}
-		// Any walk error, including a root that is a symlink, aborts.
-		var walkErr error
-		err := bfs.WalkRegular(root, func(rel string) error {
-			if path.Ext(rel) != ".md" {
+		err := filepath.WalkDir(base, func(path string, d os.DirEntry, walkErr error) error {
+			if walkErr != nil {
+				return walkErr
+			}
+			if d.IsDir() {
 				return nil
 			}
-			if err := indexDoc(ctx, store, bfs, rel); err != nil {
+			if filepath.Ext(path) != ".md" {
+				return nil
+			}
+			rel, relErr := filepath.Rel(brainDir, path)
+			if relErr != nil {
+				return fmt.Errorf("rel %q: %w", path, relErr)
+			}
+			rel = filepath.ToSlash(rel)
+			if err := IndexDoc(ctx, store, brainDir, rel); err != nil {
 				return fmt.Errorf("index %q: %w", rel, err)
 			}
 			indexed++
 			return nil
-		}, func(rel string, err error) {
-			if walkErr == nil {
-				walkErr = fmt.Errorf("%s: %w", rel, err)
-			}
 		})
-		if err == nil {
-			err = walkErr
-		}
 		if err != nil {
 			return indexed, fmt.Errorf("walk %s: %w", root, err)
 		}

ingestion/internal/graphsync/graphsync_root_test.go

@@ -1,92 +0,0 @@
-package graphsync
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-)
-
-func (f *fakeStore) dump() string {
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	return fmt.Sprintf("%+v %+v", f.upserts, f.replaces)
-}
-
-// hyperguild#157 slice 4: IndexDoc and BackfillFromBrainDir read notes with
-// os.ReadFile, so a symlinked note put the target's title and wikilinks into
-// the graph, and a FIFO hung the read.
-func TestIndexDocRefusesSymlinksAndSurvivesSwapRaces(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(facts, "ok.md"), []byte("---\ntitle: zqinside\n---\nbody [[other]]\n"), 0o644))
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(facts, "leak.md")))
-
-	store := newFakeStore()
-	require.NoError(t, IndexDoc(context.Background(), store, brain, "wiki/w/facts/ok.md"))
-	assert.Contains(t, store.dump(), "zqinside", "positive control: a regular note is indexed")
-	assert.Error(t, IndexDoc(context.Background(), store, brain, "wiki/w/facts/leak.md"))
-	// A link to a file elsewhere in the brain: os.Root allows it, only the
-	// regular-file check refuses it.
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "inlink.md")))
-	assert.Error(t, IndexDoc(context.Background(), store, brain, "wiki/w/facts/inlink.md"))
-	assert.NotContains(t, store.dump(), brainfstest.Sentinel)
-
-	p := filepath.Join(facts, "r.md")
-	read := func() string {
-		s := newFakeStore()
-		_ = IndexDoc(context.Background(), s, brain, "wiki/w/facts/r.md")
-		return s.dump()
-	}
-	brainfstest.AssertNoLeak(t, p, "---\ntitle: zqinside\n---\n", 1500*time.Millisecond, read)
-	brainfstest.AssertNoLeakFrom(t, p, "---\ntitle: zqinside\n---\n", inBrain, 1500*time.Millisecond, read)
-	brainfstest.AssertNoHang(t, p, "---\ntitle: zqinside\n---\n", 1500*time.Millisecond, 6*time.Second, func() { _ = read() })
-}
-
-func TestBackfillSkipsSymlinkedNotesAndAbortsOnASymlinkedRoot(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(facts, "ok.md"), []byte("---\ntitle: zqinside\n---\n"), 0o644))
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(facts, "leak.md")))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "raw"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "raw", "r.md"), []byte("---\ntitle: zqrawonly\n---\n"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "r.md"), filepath.Join(facts, "inlink.md")))
-	require.NoError(t, os.Symlink(".", filepath.Join(brain, "knowledge")))
-
-	store := newFakeStore()
-	_, err := BackfillFromBrainDir(context.Background(), store, brain)
-	assert.Error(t, err, "a symlinked root aborts the backfill")
-	assert.NotContains(t, store.dump(), brainfstest.Sentinel)
-	assert.NotContains(t, store.dump(), "zqrawonly")
-
-	require.NoError(t, os.Remove(filepath.Join(brain, "knowledge")))
-	store = newFakeStore()
-	n, err := BackfillFromBrainDir(context.Background(), store, brain)
-	require.NoError(t, err)
-	assert.Equal(t, 1, n, "only the regular note is indexed")
-	assert.Contains(t, store.dump(), "zqinside")
-	assert.NotContains(t, store.dump(), brainfstest.Sentinel)
-}
-
-// IndexDoc gets caller-supplied paths (brain_tunnel, brain_update): only a
-// clean path under wiki/ or knowledge/ is indexed.
-func TestIndexDocRefusesPathsOutsideWikiAndKnowledgeAndUncleanPaths(t *testing.T) {
-	brain := t.TempDir()
-	brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "secret.md"))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki", "w"), 0o755))
-	for _, p := range []string{"raw/secret.md", "wiki/w/../../raw/secret.md", "./raw/secret.md", "/raw/secret.md"} {
-		store := newFakeStore()
-		assert.Error(t, IndexDoc(context.Background(), store, brain, p), p)
-		assert.NotContains(t, store.dump(), brainfstest.Sentinel, p)
-	}
-}

ingestion/internal/mcp/handlers.go

@@ -12,6 +12,7 @@ import (
 	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/brain"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/capture"
+	"github.com/mathiasbq/hyperguild/ingestion/internal/extract"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/graphsync"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/notes"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
@@ -548,7 +549,7 @@ func (s *Server) brainIngest(ctx context.Context, args json.RawMessage) (json.Ra
 			return nil, err
 		}
 		a.Path = resolved
-		text, err := api.ReadIngestFile(s.brainDir, a.Path)
+		text, err := extract.Text(a.Path)
 		if err != nil {
 			return nil, fmt.Errorf("extract: %w", err)
 		}

ingestion/internal/mcp/readexcerpt_root_test.go

@@ -1,42 +0,0 @@
-package mcp
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-)
-
-// hyperguild#157 slice 2: readExcerpt (brain_context) read by path, so a
-// symlink in the Syncthing-shared brain put an outside file in context, and
-// a FIFO hung it. It now reads through brainfs.
-func TestReadExcerptRefusesSymlinksAndSurvivesSwapRaces(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(facts, "leak.md")))
-	assert.NotContains(t, readExcerpt(brain, "wiki/w/facts/leak.md", 500), brainfstest.Sentinel)
-	// A link to a file elsewhere in the brain: os.Root allows it, only the
-	// regular-file check refuses it (hyperguild#171).
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "inlink.md")))
-	assert.NotContains(t, readExcerpt(brain, "wiki/w/facts/inlink.md", 500), brainfstest.Sentinel)
-
-	p := filepath.Join(facts, "r.md")
-	require.NoError(t, os.WriteFile(p, []byte("---\nx: y\n---\ninside"), 0o644))
-	assert.Equal(t, "inside", readExcerpt(brain, "wiki/w/facts/r.md", 500))
-	brainfstest.AssertNoLeak(t, p, "---\nx: y\n---\ninside", 1500*time.Millisecond, func() string {
-		return readExcerpt(brain, "wiki/w/facts/r.md", 500)
-	})
-	brainfstest.AssertNoLeakFrom(t, p, "---\nx: y\n---\ninside", inBrain, 1500*time.Millisecond, func() string {
-		return readExcerpt(brain, "wiki/w/facts/r.md", 500)
-	})
-	brainfstest.AssertNoHang(t, p, "---\nx: y\n---\ninside", 1500*time.Millisecond, 6*time.Second, func() {
-		_ = readExcerpt(brain, "wiki/w/facts/r.md", 500)
-	})
-}

ingestion/internal/mcp/tools_context.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
+	"os"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -181,13 +181,8 @@ func readExcerpt(brainDir, relPath string, maxLen int) string {
 	if relPath == "" {
 		return ""
 	}
-	// Through the brain root, regular files only (hyperguild#157).
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return ""
-	}
-	defer func() { _ = bfs.Close() }()
-	content, err := bfs.ReadRegular(filepath.ToSlash(relPath))
+	full := filepath.Join(brainDir, filepath.FromSlash(relPath))
+	content, err := os.ReadFile(full)
 	if err != nil {
 		return ""
 	}

ingestion/internal/notes/edit.go

@@ -5,7 +5,6 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -72,18 +71,14 @@ func ReadScoped(brainDir, path string, scope Scope) ([]byte, error) {
 }
 
 func readContained(t Target) ([]byte, error) {
-	// Through the brain root, regular files only, size checked on the opened
-	// handle (hyperguild#157): Resolve's Lstat could be raced by a swap, and
-	// os.ReadFile blocked on a FIFO.
-	bfs, err := brainfs.Open(t.Brain)
+	fi, err := os.Stat(t.Abs)
 	if err != nil {
-		return nil, fmt.Errorf("notes: %w", err)
+		return nil, fmt.Errorf("notes: stat %s: %w", t.Rel, err)
 	}
-	defer func() { _ = bfs.Close() }()
-	b, err := bfs.ReadRegularMax(t.Rel, maxNoteBytes)
-	if errors.Is(err, brainfs.ErrTooLarge) {
-		return nil, fmt.Errorf("%w: %s (limit %d)", ErrTooLarge, t.Rel, maxNoteBytes)
+	if fi.Size() > maxNoteBytes {
+		return nil, fmt.Errorf("%w: %s is %d bytes (limit %d)", ErrTooLarge, t.Rel, fi.Size(), maxNoteBytes)
 	}
+	b, err := os.ReadFile(t.Abs)
 	if err != nil {
 		return nil, fmt.Errorf("notes: read %s: %w", t.Rel, err)
 	}

ingestion/internal/notes/edit_redirect_test.go

@@ -1,36 +0,0 @@
-package notes
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// hyperguild#188/#173: brain_edit's atomic rename must not be redirected by
-// a symlinked directory inside the brain.
-func TestEditRefusesANoteBehindASymlinkedDirectory(t *testing.T) {
-	b := t.TempDir()
-	// Edit refuses a tree that is not the sync source before any path
-	// check, so the test needs a .git to reach the symlink refusal.
-	require.NoError(t, os.MkdirAll(filepath.Join(b, ".git"), 0o755))
-	victim := filepath.Join(b, "raw", "facts", "v.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("old text\n"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "w"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "facts"), filepath.Join(b, "wiki", "w", "alias")))
-	_, err := Edit(b, "wiki/w/alias/v.md", "old text", "new text", ScopeNotes)
-	assert.Error(t, err)
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "old text\n", string(got))
-
-	real := filepath.Join(b, "wiki", "w", "facts", "r.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(real), 0o755))
-	require.NoError(t, os.WriteFile(real, []byte("old text\n"), 0o644))
-	_, err = Edit(b, "wiki/w/facts/r.md", "old text", "new text", ScopeNotes)
-	require.NoError(t, err, "positive control: a note in a real directory is edited")
-	got, _ = os.ReadFile(real)
-	assert.Equal(t, "new text\n", string(got))
-}

ingestion/internal/notes/path.go

@@ -60,7 +60,6 @@ var (
 type Target struct {
 	Rel string // brain-relative, cleaned
 	Abs string // absolute, symlink-checked
-	Brain string // the brain root Rel is relative to
 }
 
 // Resolve canonicalises path, then checks it against the scope's allowlist,
@@ -110,7 +109,7 @@ func Resolve(brainDir, path string, scope Scope) (Target, error) {
 		return Target{}, err
 	}
 
-	return Target{Rel: clean, Abs: abs, Brain: brainDir}, nil
+	return Target{Rel: clean, Abs: abs}, nil
 }
 
 // allow enforces the scope's allowlist. The two scopes are DISJOINT, not

ingestion/internal/notes/read_root_test.go

@@ -1,68 +0,0 @@
-package notes
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-)
-
-// hyperguild#157 slice 2: ReadScoped (brain_read) Lstat-checked the final
-// component, then reopened by name with os.ReadFile: a swap after the check
-// was followed, and a FIFO blocked the read. It now reads through brainfs.
-func TestReadScopedRefusesSymlinksAndSurvivesSwapRaces(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	p := filepath.Join(facts, "r.md")
-	read := func() string {
-		b, _ := ReadScoped(brain, "wiki/w/facts/r.md", ScopeNotes)
-		return string(b)
-	}
-	require.NoError(t, os.WriteFile(p, []byte("inside"), 0o644))
-	assert.Equal(t, "inside", read())
-	brainfstest.AssertNoLeak(t, p, "inside", 1500*time.Millisecond, read)
-	brainfstest.AssertNoHang(t, p, "inside", 1500*time.Millisecond, 6*time.Second, func() { _ = read() })
-}
-
-func TestReadScopedRefusesANoteOverMaxNoteBytes(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(facts, "big.md"), make([]byte, maxNoteBytes+1), 0o644))
-	_, err := ReadScoped(brain, "wiki/w/facts/big.md", ScopeNotes)
-	assert.ErrorIs(t, err, ErrTooLarge)
-}
-
-// hyperguild#171 (review of #172, finding 1): os.Root alone refuses links that
-// leave the brain, so the outside-target race above stays green for a reader
-// that skips brainfs's Lstat and SameFile checks. An in-brain target (raw/,
-// outside ScopeNotes) is what tells them apart.
-func TestReadScopedDoesNotReturnAnInBrainSymlinkTargetStaticallyOrDuringASampledSwapRace(t *testing.T) {
-	brain := t.TempDir()
-	facts := filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	target := brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "inlink.md")))
-	b, err := ReadScoped(brain, "wiki/w/facts/inlink.md", ScopeNotes)
-	assert.Error(t, err, "static in-brain link")
-	assert.NotContains(t, string(b), brainfstest.Sentinel, "static in-brain link")
-
-	p := filepath.Join(facts, "r.md")
-	require.NoError(t, os.WriteFile(p, []byte("inside"), 0o644))
-	b, err = ReadScoped(brain, "wiki/w/facts/r.md", ScopeNotes)
-	require.NoError(t, err)
-	assert.Equal(t, "inside", string(b), "positive control: a regular note reads")
-
-	read := func() string {
-		b, _ := ReadScoped(brain, "wiki/w/facts/r.md", ScopeNotes)
-		return string(b)
-	}
-	brainfstest.AssertNoLeakFrom(t, p, "inside", target, 1500*time.Millisecond, read)
-}

ingestion/internal/pipeline/backfill.go

@@ -3,10 +3,7 @@ package pipeline
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -26,16 +23,10 @@ func BackfillRefs(ctx context.Context, brainDir string) (int, error) {
 		return 0, fmt.Errorf("load inventory: %w", err)
 	}
 
-	// Listed and read through the brain root, regular files only
-	// (hyperguild#157).
-	bfs, err := brainfs.Open(brainDir)
+	sourcesDir := filepath.Join(brainDir, "wiki", "sources")
+	entries, err := os.ReadDir(sourcesDir)
 	if err != nil {
-		return 0, fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-	names, err := bfs.ReadDirRegular("wiki/sources")
-	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
+		if os.IsNotExist(err) {
 			return 0, nil
 		}
 		return 0, fmt.Errorf("read sources dir: %w", err)
@@ -46,20 +37,20 @@ func BackfillRefs(ctx context.Context, brainDir string) (int, error) {
 	// get both refs merged before a single write.
 	pending := make(map[string]wiki.Page)
 
-	for _, name := range names {
+	for _, e := range entries {
 		if ctx.Err() != nil {
 			return 0, ctx.Err()
 		}
-		if !strings.HasSuffix(name, ".md") {
+		if e.IsDir() || !strings.HasSuffix(e.Name(), ".md") {
 			continue
 		}
 
-		b, err := bfs.ReadRegular("wiki/sources/" + name)
+		b, err := os.ReadFile(filepath.Join(sourcesDir, e.Name()))
 		if err != nil {
 			continue
 		}
 		sourceContent := string(b)
-		sourceSlug := strings.TrimSuffix(name, ".md")
+		sourceSlug := strings.TrimSuffix(e.Name(), ".md")
 		sourceTitle := extractTitle(sourceContent)
 		if sourceTitle == "" {
 			sourceTitle = sourceSlug
@@ -79,7 +70,7 @@ func BackfillRefs(ctx context.Context, brainDir string) (int, error) {
 			// Start from already-accumulated version if we've seen this page.
 			page, seen := pending[relPath]
 			if !seen {
-				raw, err := bfs.ReadRegular(relPath)
+				raw, err := os.ReadFile(filepath.Join(brainDir, filepath.FromSlash(relPath)))
 				if err != nil {
 					continue
 				}

ingestion/internal/pipeline/pipeline.go

@@ -5,10 +5,7 @@ import (
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
-	"errors"
 	"fmt"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
-	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -132,7 +129,7 @@ func buildAndWrite(ctx context.Context, rawPages []RawPage, sourceSlug, date, br
 			if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
 				return Result{}, fmt.Errorf("mkdir for %s: %w", page.Path, err)
 			}
-			content, conflicts, err := reviseOrCreate(brainDir, page)
+			content, conflicts, err := reviseOrCreate(dest, page)
 			if err != nil {
 				return Result{}, err
 			}
@@ -191,27 +188,14 @@ func hashBody(content string) string {
 
 // readSourcePage returns the full on-disk content of the source page at
 // wiki/sources/<sourceSlug>.md, or "" when it doesn't exist yet.
-// It reads through the brain root, regular files only (hyperguild#157): the
-// content goes into the LLM prompt.
 func readSourcePage(brainDir, sourceSlug string) string {
-	raw, err := readBrainFile(brainDir, "wiki/sources/"+sourceSlug+".md")
+	raw, err := os.ReadFile(filepath.Join(brainDir, "wiki", "sources", sourceSlug+".md"))
 	if err != nil {
 		return ""
 	}
 	return string(raw)
 }
 
-// readBrainFile reads one brain-relative file through the brain root,
-// regular files only (hyperguild#157).
-func readBrainFile(brainDir, rel string) ([]byte, error) {
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return nil, err
-	}
-	defer func() { _ = bfs.Close() }()
-	return bfs.ReadRegular(rel)
-}
-
 // storedSourceHash reads source_hash from the source page a previous ingest
 // wrote, or "" when there is no such page or no such field.
 //
@@ -246,10 +230,10 @@ func storedSourceHash(brainDir, sourceSlug string) string {
 // 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(brainDir string, page wiki.Page) (string, []string, error) {
-	existing, err := readBrainFile(brainDir, page.Path)
+func reviseOrCreate(dest string, page wiki.Page) (string, []string, error) {
+	existing, err := os.ReadFile(dest)
 	switch {
-	case errors.Is(err, fs.ErrNotExist):
+	case os.IsNotExist(err):
 		return page.Content, nil, nil
 	case err != nil:
 		return "", nil, fmt.Errorf("read existing %s: %w", page.Path, err)
@@ -283,7 +267,7 @@ See brain/schema.md for the full schema.
 `
 
 func loadSchema(brainDir string) string {
-	b, err := readBrainFile(brainDir, "schema.md")
+	b, err := os.ReadFile(filepath.Join(brainDir, "schema.md"))
 	if err != nil {
 		return defaultSchema
 	}

ingestion/internal/pipeline/refs.go

@@ -2,6 +2,7 @@
 package pipeline
 
 import (
+	"os"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -52,7 +53,8 @@ func injectSourceRefs(pages []wiki.Page, inventory map[wiki.PageType][]wiki.Entr
 		if !ok {
 			continue
 		}
-		b, err := readBrainFile(brainDir, "wiki/"+string(pt)+"/"+slug+".md")
+		diskPath := filepath.Join(brainDir, "wiki", string(pt), slug+".md")
+		b, err := os.ReadFile(diskPath)
 		if err != nil {
 			continue
 		}

ingestion/internal/pipeline/root_test.go

@@ -1,167 +0,0 @@
-package pipeline
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
-)
-
-// hyperguild#157 slice 6: the pipeline read the source page, schema.md, the
-// pages it revises and the pages it adds source refs to with os.ReadFile, so
-// a symlinked file's content reached the LLM prompt and the written pages,
-// and a FIFO hung the ingest.
-
-func mkdirs(t *testing.T, brain string, dirs ...string) {
-	t.Helper()
-	for _, d := range dirs {
-		require.NoError(t, os.MkdirAll(filepath.Join(brain, filepath.FromSlash(d)), 0o755))
-	}
-}
-
-func TestReadSourcePageAndSchemaRefuseSymlinksAndSurviveSwapRaces(t *testing.T) {
-	brain := t.TempDir()
-	mkdirs(t, brain, "wiki/sources")
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "wiki", "sources", "ok.md"), []byte("zqinside source"), 0o644))
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "schema.md"), []byte("zqinside schema"), 0o644))
-	assert.Equal(t, "zqinside source", readSourcePage(brain, "ok"), "positive control")
-	assert.Equal(t, "zqinside schema", loadSchema(brain), "positive control")
-
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(brain, "wiki", "sources", "out.md")))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "s.md"), filepath.Join(brain, "wiki", "sources", "in.md")))
-	assert.NotContains(t, readSourcePage(brain, "out"), brainfstest.Sentinel)
-	assert.NotContains(t, readSourcePage(brain, "in"), brainfstest.Sentinel)
-	assert.NotContains(t, storedSourceHash(brain, "in"), brainfstest.Sentinel)
-
-	src := filepath.Join(brain, "wiki", "sources", "r.md")
-	read := func() string { return readSourcePage(brain, "r") }
-	brainfstest.AssertNoLeak(t, src, "zqinside", 1500*time.Millisecond, read)
-	brainfstest.AssertNoLeakFrom(t, src, "zqinside", inBrain, 1500*time.Millisecond, read)
-	brainfstest.AssertNoHang(t, src, "zqinside", 1500*time.Millisecond, 6*time.Second, func() { _ = read() })
-
-	schema := filepath.Join(brain, "schema.md")
-	rs := func() string { return loadSchema(brain) }
-	brainfstest.AssertNoLeakFrom(t, schema, "zqinside schema", inBrain, 1500*time.Millisecond, rs)
-	brainfstest.AssertNoHang(t, schema, "zqinside schema", 1500*time.Millisecond, 6*time.Second, func() { _ = rs() })
-}
-
-func TestReviseOrCreateRefusesASymlinkedExistingPage(t *testing.T) {
-	brain := t.TempDir()
-	mkdirs(t, brain, "wiki/concepts")
-	brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "s.md"), filepath.Join(brain, "wiki", "concepts", "c.md")))
-	page := wiki.Page{Path: "wiki/concepts/c.md", Content: "---\ntitle: C\n---\nnew\n"}
-	out, _, err := reviseOrCreate(brain, page)
-	assert.Error(t, err)
-	assert.NotContains(t, out, brainfstest.Sentinel)
-
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "wiki", "concepts", "d.md"), []byte("---\ntitle: D\n---\nzqold\n"), 0o644))
-	out, _, err = reviseOrCreate(brain, wiki.Page{Path: "wiki/concepts/d.md", Content: "---\ntitle: D\n---\nnew\n"})
-	require.NoError(t, err)
-	assert.Contains(t, out, "zqold", "positive control: the existing page is read")
-	out, _, err = reviseOrCreate(brain, wiki.Page{Path: "wiki/concepts/new.md", Content: "fresh"})
-	require.NoError(t, err)
-	assert.Equal(t, "fresh", out, "positive control: a missing page is created")
-}
-
-func TestInjectSourceRefsDoesNotReadASymlinkedPage(t *testing.T) {
-	brain := t.TempDir()
-	mkdirs(t, brain, "wiki/concepts")
-	brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "s.md"), filepath.Join(brain, "wiki", "concepts", "c.md")))
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "wiki", "concepts", "d.md"), []byte("zqinside d"), 0o644))
-	inv := map[wiki.PageType][]wiki.Entry{wiki.PageTypeConcept: {
-		{Slug: "c", Type: wiki.PageTypeConcept}, {Slug: "d", Type: wiki.PageTypeConcept},
-	}}
-	src := wiki.Page{Path: "wiki/sources/src.md", Content: "---\ntitle: Src\n---\nsee [[c|C]] and [[d|D]]\n"}
-	out := injectSourceRefs([]wiki.Page{src}, inv, brain)
-	got := fmt.Sprintf("%+v", out)
-	assert.Contains(t, got, "zqinside d", "positive control")
-	assert.NotContains(t, got, brainfstest.Sentinel)
-}
-
-func TestBackfillRefsSkipsSymlinkedSourcesAndPages(t *testing.T) {
-	brain := t.TempDir()
-	mkdirs(t, brain, "wiki/sources", "wiki/concepts", "raw")
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "wiki", "concepts", "real.md"), []byte("---\ntitle: R\n---\nbody\n"), 0o644))
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "wiki", "sources", "ok.md"), []byte("---\ntitle: zqinside\n---\n[[real|R]]\n"), 0o644))
-	// A source elsewhere in the brain whose title is the sentinel and which
-	// links the real concept with the [[slug|title]] form the pipeline follows.
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "raw", "src.md"),
-		[]byte("---\ntitle: "+brainfstest.Sentinel+"\n---\n[[real|R]]\n"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "src.md"), filepath.Join(brain, "wiki", "sources", "in.md")))
-	// A concept page linked by the regular source that is itself a symlink.
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "wiki", "sources", "ok2.md"), []byte("---\ntitle: Two\n---\n[[lnk|L]]\n"), 0o644))
-	brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "page.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "page.md"), filepath.Join(brain, "wiki", "concepts", "lnk.md")))
-
-	_, err := BackfillRefs(context.Background(), brain)
-	require.NoError(t, err)
-	b, _ := os.ReadFile(filepath.Join(brain, "wiki", "concepts", "real.md"))
-	assert.Contains(t, string(b), "zqinside", "positive control: the regular source's ref is added")
-	assert.NotContains(t, string(b), brainfstest.Sentinel, "a symlinked source's title was written as a ref")
-	raw, _ := os.ReadFile(filepath.Join(brain, "raw", "page.md"))
-	assert.NotContains(t, string(raw), "[[ok2", "the symlinked concept page's target was rewritten")
-}
-
-// A source swapped between a regular file and a symlink to an in-brain source
-// whose title is the sentinel: the read refuses the swapped-in link, so the
-// sentinel never lands in the concept page as a ref.
-func TestBackfillRefsDoesNotWriteARefFromASourceSwappedInBehindASymlink(t *testing.T) {
-	brain := t.TempDir()
-	mkdirs(t, brain, "wiki/sources", "wiki/concepts", "raw")
-	realPage := filepath.Join(brain, "wiki", "concepts", "real.md")
-	target := filepath.Join(brain, "raw", "src.md")
-	require.NoError(t, os.WriteFile(target, []byte("---\ntitle: "+brainfstest.Sentinel+"\n---\n[[real|R]]\n"), 0o644))
-	src := filepath.Join(brain, "wiki", "sources", "r.md")
-	inside := "---\ntitle: zqinside\n---\n[[real|R]]\n"
-	read := func() string {
-		_ = os.WriteFile(realPage, []byte("---\ntitle: R\n---\nbody\n"), 0o644)
-		_, _ = BackfillRefs(context.Background(), brain)
-		b, _ := os.ReadFile(realPage)
-		return string(b)
-	}
-	require.NoError(t, os.WriteFile(src, []byte(inside), 0o644))
-	require.Contains(t, read(), "zqinside", "positive control")
-	brainfstest.AssertNoLeakFrom(t, src, inside, target, 1500*time.Millisecond, read)
-}
-
-// A concept page that is regular when the inventory lists it, then swapped
-// for a symlink to an in-brain file before BackfillRefs reads it: only the
-// page read's own check refuses it (a static symlink never gets this far,
-// because LoadInventory does not list it).
-func TestBackfillRefsDoesNotCopyAPageSwappedInBehindASymlink(t *testing.T) {
-	brain := t.TempDir()
-	mkdirs(t, brain, "wiki/sources", "wiki/concepts", "raw")
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "wiki", "sources", "s.md"), []byte("---\ntitle: S\n---\n[[c|C]]\n"), 0o644))
-	page := filepath.Join(brain, "wiki", "concepts", "c.md")
-	target := filepath.Join(brain, "raw", "secret.md")
-	inside := "---\ntitle: C\n---\nzqinside\n"
-	read := func() string {
-		// The write path still follows a swapped-in link (#158) and can
-		// overwrite the target, so restore it each round.
-		_ = os.WriteFile(target, []byte("---\ntitle: X\n---\n"+brainfstest.Sentinel+"\n"), 0o644)
-		_, _ = BackfillRefs(context.Background(), brain)
-		f, err := os.OpenFile(page, os.O_RDONLY|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0)
-		if err != nil {
-			return ""
-		}
-		defer func() { _ = f.Close() }()
-		b, _ := io.ReadAll(f)
-		return string(b)
-	}
-	require.NoError(t, os.WriteFile(page, []byte(inside), 0o644))
-	require.Contains(t, read(), "[[s|S]]", "positive control: the regular page gets the source ref")
-	brainfstest.AssertNoLeakFrom(t, page, inside, target, 3*time.Second, read)
-}

ingestion/internal/provenance/provenance.go

@@ -28,6 +28,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"os"
 	"regexp"
 	"strings"
 
@@ -101,6 +102,25 @@ func Apply(content string, s Stamp) (string, error) {
 	return out, nil
 }
 
+// ApplyFile applies the stamp to the note at absPath in place.
+func ApplyFile(absPath string, s Stamp) error {
+	b, err := os.ReadFile(absPath)
+	if err != nil {
+		return fmt.Errorf("read for provenance: %w", err)
+	}
+	out, err := Apply(string(b), s)
+	if err != nil {
+		return err
+	}
+	if out == string(b) {
+		return nil
+	}
+	if err := os.WriteFile(absPath, []byte(out), 0o644); err != nil {
+		return fmt.Errorf("write provenance: %w", err)
+	}
+	return nil
+}
+
 // plainGroups keeps the provably plain key groups of a frontmatter block.
 func plainGroups(block string) string {
 	lines := strings.Split(strings.TrimSuffix(block, "\n"), "\n")

ingestion/internal/search/brainroot_test.go

@@ -1,239 +0,0 @@
-package search
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-)
-
-// hyperguild#157 option 1: search walked and read the brain by path, so a
-// symlink anywhere in the Syncthing-shared brain dir (wiki/<w>/<h>/leak.md ->
-// /any/file) put the target's contents in brain_query results (reproduced in
-// the PR #156 review). Search now walks and reads through an os.Root on the
-// brain dir and only reads regular files.
-
-const sentinel157 = "zqsentinelonefiftyseven"
-
-func searchBrain(t *testing.T) (brain, facts, outside string) {
-	t.Helper()
-	brain = t.TempDir()
-	facts = filepath.Join(brain, "wiki", "w", "facts")
-	require.NoError(t, os.MkdirAll(facts, 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "knowledge"), 0o755))
-	outside = filepath.Join(t.TempDir(), "secret.md")
-	require.NoError(t, os.WriteFile(outside, []byte("# secret\n\n"+sentinel157), 0o644))
-	return brain, facts, outside
-}
-
-func leaked(rs []Result) int {
-	n := 0
-	for _, r := range rs {
-		n += strings.Count(r.Excerpt+r.Title, sentinel157)
-	}
-	return n
-}
-
-func TestQueryDoesNotFollowASymlinkInTheWiki(t *testing.T) {
-	brain, facts, outside := searchBrain(t)
-	require.NoError(t, os.Symlink(outside, filepath.Join(facts, "leak.md")))
-	require.NoError(t, os.WriteFile(filepath.Join(facts, "real.md"), []byte("# real\n\nzqrealnote"), 0o644))
-	rs, err := Query(brain, QueryOptions{Query: sentinel157, Limit: 10})
-	require.NoError(t, err)
-	assert.Zero(t, leaked(rs))
-	rs, err = Query(brain, QueryOptions{Query: "zqrealnote", Limit: 10})
-	require.NoError(t, err)
-	assert.Len(t, rs, 1, "regular notes are still found")
-}
-
-func TestQueryDoesNotFollowASymlinkedDirectory(t *testing.T) {
-	brain, _, outside := searchBrain(t)
-	require.NoError(t, os.Symlink(filepath.Dir(outside), filepath.Join(brain, "wiki", "linked")))
-	rs, err := Query(brain, QueryOptions{Query: sentinel157, Limit: 10})
-	require.NoError(t, err)
-	assert.Zero(t, leaked(rs))
-}
-
-// A search root that is a symlink staying inside the brain (wiki/<w> -> ..)
-// was followed by fs.WalkDir, aliasing raw/ and root files into results
-// (PR #166 review). The root is now Lstat-checked and skipped.
-func TestQueryDoesNotFollowASymlinkedWingRootInsideTheBrain(t *testing.T) {
-	brain, _, _ := searchBrain(t)
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "raw"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "raw", "r.md"), []byte("# r\n\nzqrawonly"), 0o644))
-	require.NoError(t, os.Symlink("..", filepath.Join(brain, "wiki", "alias")))
-	rs, err := Query(brain, QueryOptions{Query: "zqrawonly", Wing: "alias", Limit: 10})
-	require.NoError(t, err)
-	assert.Empty(t, rs)
-}
-
-// With a hall the search root is wiki/<wing>/<hall>; a symlinked <wing> with
-// a real <hall> directory under its target was followed (PR #166 round 2).
-func TestQueryDoesNotFollowASymlinkedWingUnderAWingAndHallRoot(t *testing.T) {
-	brain, _, _ := searchBrain(t)
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "raw", "facts"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "raw", "facts", "r.md"), []byte("# r\n\nzqrawhall"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(brain, "wiki", "alias")))
-	rs, err := Query(brain, QueryOptions{Query: "zqrawhall", Wing: "alias", Hall: "facts", Limit: 10})
-	require.NoError(t, err)
-	assert.Empty(t, rs)
-}
-
-// swapInto keeps renaming a regular note, and either a symlink to outside or
-// a FIFO, into path. Each FIFO has a writer held open (as any local process
-// can): a FIFO with no writer reads EOF at once, which would let a reader
-// that skips the handle check pass (PR #161 round 2: with a held writer, a
-// bypass of readOpened hung Query after 5 iterations).
-// startSwap runs swapInto until the test ends and waits for it before
-// t.TempDir's cleanup (hyperguild#162).
-// It returns the count of symlinks or FIFOs actually renamed into path
-// (hyperguild#177: a swapper whose every swap fails tests nothing).
-func startSwap(t *testing.T, path, outside string, fifo bool) *atomic.Int64 {
-	t.Helper()
-	var stop atomic.Bool
-	var swaps atomic.Int64
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() { defer wg.Done(); swapInto(path, outside, fifo, &stop, &swaps) }()
-	t.Cleanup(func() { stop.Store(true); wg.Wait() })
-	return &swaps
-}
-
-func swapInto(path, outside string, fifo bool, stop *atomic.Bool, swaps *atomic.Int64) {
-	tmp := path + ".swap"
-	// Writers stay open until the swapper exits, so a reader parked on a
-	// FIFO stays parked (closing one would hand the reader EOF and hide the
-	// hang). Past the fd limit, new FIFOs simply have no writer.
-	var writers []*os.File
-	defer func() {
-		for _, w := range writers {
-			_ = w.Close()
-		}
-	}()
-	for i := 0; !stop.Load(); i++ {
-		_ = os.Remove(tmp)
-		var made error
-		switch {
-		case i%2 == 0:
-			_ = os.WriteFile(tmp, []byte("# r\n\nzqinside "+"zqracenote"), 0o644)
-		case fifo:
-			if made = syscall.Mkfifo(tmp, 0o644); made == nil {
-				if w, err := os.OpenFile(tmp, os.O_RDWR, 0); err == nil {
-					writers = append(writers, w)
-				}
-			}
-		default:
-			made = os.Symlink(outside, tmp)
-		}
-		if err := os.Rename(tmp, path); err == nil && made == nil && i%2 == 1 {
-			swaps.Add(1)
-		}
-	}
-}
-
-func TestQueryLeaksNothingUnderASymlinkSwapRace(t *testing.T) {
-	brain, facts, outside := searchBrain(t)
-	swaps := startSwap(t, filepath.Join(facts, "r.md"), outside, false)
-	leaks, iters, insideReads := 0, 0, 0
-	for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); iters++ {
-		rs, err := Query(brain, QueryOptions{Query: sentinel157, Limit: 10})
-		require.NoError(t, err)
-		leaks += leaked(rs)
-		// Positive control (hyperguild#177): a Query that always errors
-		// returns nothing and so never leaks.
-		rs, err = Query(brain, QueryOptions{Query: "zqracenote", Limit: 10})
-		require.NoError(t, err)
-		if len(rs) > 0 {
-			insideReads++
-		}
-	}
-	if leaks > 0 {
-		t.Fatalf("outside file leaked %d times in %d iterations", leaks, iters)
-	}
-	require.Positive(t, swaps.Load(), "no symlink was swapped in: the race did not run")
-	require.Positive(t, insideReads, "no Query returned the inside note")
-}
-
-func TestQueryDoesNotHangUnderAFIFOSwapRace(t *testing.T) {
-	brain, facts, outside := searchBrain(t)
-	startSwap(t, filepath.Join(facts, "r.md"), outside, true)
-	done := make(chan struct{})
-	go func() {
-		for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); {
-			_, _ = Query(brain, QueryOptions{Query: "zqracenote", Limit: 10})
-		}
-		close(done)
-	}()
-	select {
-	case <-done:
-	case <-time.After(6 * time.Second):
-		if f, err := os.OpenFile(filepath.Join(facts, "r.md"), os.O_WRONLY|syscall.O_NONBLOCK, 0); err == nil {
-			_ = f.Close()
-		}
-		t.Fatal("search hung on a swapped-in FIFO")
-	}
-}
-
-// hydrate (vector-only hits) reads by relative path; it must refuse a symlink.
-func TestHydrateRefusesASymlink(t *testing.T) {
-	brain, facts, outside := searchBrain(t)
-	require.NoError(t, os.Symlink(outside, filepath.Join(facts, "leak.md")))
-	r, err := hydrate(brain, "wiki/w/facts/leak.md")
-	assert.Error(t, err)
-	assert.NotContains(t, r.Excerpt, sentinel157)
-}
-
-// hyperguild#171: os.Root refuses links that leave the brain on its own, so
-// the outside-target cases above would stay green for a caller that read
-// without brainfs's Lstat and SameFile checks. These targets are inside the
-// brain (raw/, which is not a search root).
-func inBrainTarget(t *testing.T, brain string) string {
-	t.Helper()
-	return brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-}
-
-func TestQueryDoesNotReturnAnInBrainSymlinkTargetDuringASampledSwapRace(t *testing.T) {
-	brain, facts, _ := searchBrain(t)
-	target := inBrainTarget(t, brain)
-	read := func() string {
-		// Both terms, so the regular note is a possible hit: a reader that
-		// never returns the inside note would pass vacuously (#177 floor).
-		rs, _ := Query(brain, QueryOptions{Query: brainfstest.Sentinel + " zqinside", Limit: 10})
-		s := ""
-		for _, r := range rs {
-			s += r.Title + r.Excerpt
-		}
-		return s
-	}
-	brainfstest.AssertNoLeakFrom(t, filepath.Join(facts, "r.md"), "# r\n\nzqinside", target, 1500*time.Millisecond, read)
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "inlink.md")))
-	assert.NotContains(t, read(), brainfstest.Sentinel, "static in-brain link")
-}
-
-func TestHydrateRefusesAnInBrainSymlinkAndDoesNotReturnItsTargetDuringASampledSwapRace(t *testing.T) {
-	brain, facts, _ := searchBrain(t)
-	target := inBrainTarget(t, brain)
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(facts, "inlink.md")))
-	r, err := hydrate(brain, "wiki/w/facts/inlink.md")
-	assert.Error(t, err)
-	assert.NotContains(t, r.Excerpt+r.Title, brainfstest.Sentinel)
-
-	p := filepath.Join(facts, "r.md")
-	require.NoError(t, os.WriteFile(p, []byte("# r\n\nzqinside"), 0o644))
-	r, err = hydrate(brain, "wiki/w/facts/r.md")
-	require.NoError(t, err)
-	assert.Contains(t, r.Excerpt, "zqinside", "positive control: a regular note hydrates")
-	brainfstest.AssertNoLeakFrom(t, p, "# r\n\nzqinside", target, 1500*time.Millisecond, func() string {
-		r, _ := hydrate(brain, "wiki/w/facts/r.md")
-		return r.Title + r.Excerpt
-	})
-}

ingestion/internal/search/search.go

@@ -5,7 +5,6 @@ import (
 	"bufio"
 	"context"
 	"fmt"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 	sharedfm "github.com/mathiasbq/hyperguild/ingestion/internal/frontmatter"
 	"log/slog"
 	"os"
@@ -120,30 +119,20 @@ func QueryContext(ctx context.Context, brainDir string, opts QueryOptions) ([]Re
 		return nil, err
 	}
 
-	// Walk and read through an os.Root on the brain dir, regular files only
-	// (hyperguild#157): a symlink planted in the Syncthing-shared brain must
-	// not put an outside file in results, nor a FIFO hang the query.
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return nil, fmt.Errorf("search: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-
 	var results []Result
 	for _, dir := range roots {
 		if _, statErr := os.Stat(dir); os.IsNotExist(statErr) {
 			continue
 		}
-		relDir, relErr := bfs.Rel(dir)
-		if relErr != nil {
-			return nil, fmt.Errorf("search: %w", relErr)
-		}
-		err := bfs.WalkRegular(relDir, func(relPath string) error {
-			if !strings.HasSuffix(relPath, ".md") {
+		err := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
+			if err != nil {
+				slog.Warn("search: skipping path", "path", path, "err", err)
 				return nil
 			}
-			path := filepath.Join(brainDir, filepath.FromSlash(relPath))
-			content, err := bfs.ReadRegular(relPath)
+			if d.IsDir() || !strings.HasSuffix(path, ".md") {
+				return nil
+			}
+			content, err := os.ReadFile(path)
 			if err != nil {
 				slog.Warn("search: skipping unreadable file", "path", path, "err", err)
 				return nil
@@ -166,7 +155,7 @@ func QueryContext(ctx context.Context, brainDir string, opts QueryOptions) ([]Re
 			origin, writtenBy := extractProvenance(string(content))
 			results = append(results, Result{
 				Path:    rel,
-				Title:   extractTitle(string(content), filepath.Base(relPath)),
+				Title:   extractTitle(string(content), d.Name()),
 				Excerpt: excerpt(string(content), 300),
 				Score:   score,
 				Wing:    wing,
@@ -177,8 +166,6 @@ func QueryContext(ctx context.Context, brainDir string, opts QueryOptions) ([]Re
 				WrittenBy: writtenBy,
 			})
 			return nil
-		}, func(p string, err error) {
-			slog.Warn("search: skipping path", "path", p, "err", err)
 		})
 		if err != nil {
 			return nil, err
@@ -288,13 +275,8 @@ func pathInScope(relPath, wing, hall string) bool {
 // excerpt, wing, and hall populated. Used for paths that surface only
 // via vector search.
 func hydrate(brainDir, relPath string) (Result, error) {
-	// Through the brain root, regular files only (hyperguild#157).
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return Result{}, err
-	}
-	defer func() { _ = bfs.Close() }()
-	content, err := bfs.ReadRegular(filepath.ToSlash(relPath))
+	full := filepath.Join(brainDir, filepath.FromSlash(relPath))
+	content, err := os.ReadFile(full)
 	if err != nil {
 		return Result{}, err
 	}

ingestion/internal/session/id_test.go

@@ -1,177 +0,0 @@
-package session
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"sync/atomic"
-	"syscall"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/sys/unix"
-)
-
-// session_log passed the caller's session_id straight into
-// filepath.Join(sessionsDir, id+".jsonl") and opened it O_CREATE|O_APPEND:
-// path segments in the id created or appended files anywhere the pod could
-// write. The id is now a plain name, and the open does not follow a final
-// symlink.
-func TestAppendRefusesSessionIDsThatAreNotPlainNames(t *testing.T) {
-	root := t.TempDir()
-	dir := filepath.Join(root, "sessions")
-	for _, id := range []string{"../x", "a/b", "/abs", ".", "..", ".hidden", "", "a\\b", "a\x00b"} {
-		assert.Error(t, Append(dir, id, Entry{SessionID: id}), "%q", id)
-	}
-	ents, _ := os.ReadDir(root)
-	for _, e := range ents {
-		assert.Equal(t, "sessions", e.Name(), "nothing created beside the sessions dir")
-	}
-	for _, id := range []string{"1557b2e1-bf0d-5c4f-bbe3-0754d087e356", "_routing", "2026-05-05-infra.plan", "0"} {
-		require.NoError(t, Append(dir, id, Entry{SessionID: id}), "positive control: %q", id)
-	}
-}
-
-func TestAppendDoesNotWriteThroughASymlinkedLog(t *testing.T) {
-	root := t.TempDir()
-	dir := filepath.Join(root, "sessions")
-	require.NoError(t, os.MkdirAll(dir, 0o755))
-	victim := filepath.Join(root, "victim.md")
-	require.NoError(t, os.WriteFile(victim, []byte("untouched\n"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "victim.md"), filepath.Join(dir, "s.jsonl")))
-	assert.Error(t, Append(dir, "s", Entry{SessionID: "s"}))
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "untouched\n", string(got))
-}
-
-func TestReadRefusesSessionIDsThatAreNotPlainNames(t *testing.T) {
-	root := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(root, "x.jsonl"), []byte(`{"session_id":"x"}`+"\n"), 0o644))
-	_, err := Read(filepath.Join(root, "sessions"), "../x")
-	assert.Error(t, err)
-}
-
-// A name that starts plainly and then climbs out with ".." is exactly what the
-// ban on "/" in the id's tail stops: filepath.Join cleans "a/../../x" to a
-// path beside the sessions dir without needing sessions/a to exist. The
-// assertion is on the refusal itself (ErrInvalidID), not on any error.
-func TestAppendRefusesAnIDThatClimbsOutAfterAPlainPrefix(t *testing.T) {
-	root := t.TempDir()
-	dir := filepath.Join(root, "sessions")
-	require.NoError(t, os.MkdirAll(dir, 0o755))
-	for _, id := range []string{"a/../../escape", "a/../../../escape", "a/../b"} {
-		err := Append(dir, id, Entry{SessionID: id})
-		assert.ErrorIs(t, err, ErrInvalidID, "%q", id)
-	}
-	_, err := os.Lstat(filepath.Join(root, "escape.jsonl"))
-	assert.True(t, errors.Is(err, os.ErrNotExist), "nothing created beside the sessions dir")
-	_, err = os.Lstat(filepath.Join(dir, "b.jsonl"))
-	assert.True(t, errors.Is(err, os.ErrNotExist), "no in-dir alias created either")
-}
-
-// Append does no Lstat type check, so O_NONBLOCK is the only thing that keeps
-// a FIFO named <id>.jsonl with no reader from blocking session_log forever.
-func TestAppendReturnsPromptlyOnAFIFOLogWithNoReader(t *testing.T) {
-	dir := filepath.Join(t.TempDir(), "sessions")
-	require.NoError(t, os.MkdirAll(dir, 0o755))
-	fifo := filepath.Join(dir, "s.jsonl")
-	require.NoError(t, syscall.Mkfifo(fifo, 0o644))
-	done := make(chan error, 1)
-	go func() { done <- Append(dir, "s", Entry{SessionID: "s"}) }()
-	select {
-	case err := <-done:
-		assert.Error(t, err, "a FIFO with no reader is refused, not written")
-	case <-time.After(3 * time.Second):
-		// Unblock the stuck open so the goroutine and TempDir cleanup finish.
-		if r, err := os.OpenFile(fifo, os.O_RDONLY|syscall.O_NONBLOCK, 0); err == nil {
-			defer r.Close() //nolint:errcheck
-		}
-		<-done
-		t.Fatal("Append blocked on a FIFO log with no reader")
-	}
-}
-
-// hyperguild#173: session_log followed a symlinked sessions dir.
-func TestAppendRefusesASymlinkedSessionsDir(t *testing.T) {
-	root := t.TempDir()
-	elsewhere := filepath.Join(root, "elsewhere")
-	require.NoError(t, os.MkdirAll(elsewhere, 0o755))
-	dir := filepath.Join(root, "sessions")
-	require.NoError(t, os.Symlink("elsewhere", dir))
-	assert.Error(t, Append(dir, "s", Entry{SessionID: "s"}))
-	ents, _ := os.ReadDir(elsewhere)
-	assert.Empty(t, ents, "a log was created through the symlinked dir")
-}
-
-// The sessions dir is swapped (RENAME_EXCHANGE) with a symlink to a
-// directory outside the brain while Append runs. Append opens through an
-// os.Root on the sessions dir's parent, so a swap can redirect it only
-// inside that parent (the #167 residual), never outside it.
-func TestAppendNeverCreatesALogOutsideTheParentUnderADirSwapRace(t *testing.T) {
-	brain := t.TempDir()
-	outside := t.TempDir()
-	dir := filepath.Join(brain, "sessions")
-	other := filepath.Join(brain, "sessions.link")
-	require.NoError(t, os.MkdirAll(dir, 0o755))
-	require.NoError(t, os.Symlink(outside, other))
-	var stop atomic.Bool
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for !stop.Load() {
-			_ = unix.Renameat2(unix.AT_FDCWD, dir, unix.AT_FDCWD, other, unix.RENAME_EXCHANGE)
-		}
-	}()
-	ok := 0
-	for i := 0; i < 20000; i++ {
-		if Append(dir, fmt.Sprintf("s%d", i), Entry{SessionID: "s"}) == nil {
-			ok++
-		}
-	}
-	stop.Store(true)
-	<-done
-	ents, _ := os.ReadDir(outside)
-	assert.Empty(t, ents, "logs were created outside the brain")
-	assert.Positive(t, ok, "positive control: appends to the real dir succeed")
-}
-
-// The log file is swapped between a regular file and a symlink to another
-// file in the brain while Append runs: Append writes only after confirming
-// the path is the regular file it opened, so the other file never grows.
-func TestAppendNeverWritesThroughALogSwappedForASymlink(t *testing.T) {
-	brain := t.TempDir()
-	dir := filepath.Join(brain, "sessions")
-	require.NoError(t, os.MkdirAll(dir, 0o755))
-	victim := filepath.Join(brain, "victim.md")
-	require.NoError(t, os.WriteFile(victim, []byte("untouched\n"), 0o644))
-	log := filepath.Join(dir, "s.jsonl")
-	var stop atomic.Bool
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		tmp := log + ".swap"
-		for i := 0; !stop.Load(); i++ {
-			_ = os.Remove(tmp)
-			if i%2 == 0 {
-				_ = os.WriteFile(tmp, nil, 0o644)
-			} else {
-				_ = os.Symlink(filepath.Join("..", "victim.md"), tmp)
-			}
-			_ = os.Rename(tmp, log)
-		}
-	}()
-	ok := 0
-	for i := 0; i < 20000; i++ {
-		if Append(dir, "s", Entry{SessionID: "s"}) == nil {
-			ok++
-		}
-	}
-	stop.Store(true)
-	<-done
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "untouched\n", string(got), "a log line was written through the swapped-in symlink")
-	assert.Positive(t, ok, "positive control: appends to the regular log succeed")
-}

ingestion/internal/session/session.go

@@ -9,8 +9,6 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
-	"regexp"
-	"syscall"
 	"time"
 )
 
@@ -44,63 +42,16 @@ type Attempt struct {
 	RunnerOutput  string `json:"runner_output,omitempty"`
 }
 
-// idPattern is a plain file name: session_log takes the id from the caller,
-// and a path segment in it created or appended files anywhere the pod could
-// write (hyperguild#169).
-var idPattern = regexp.MustCompile(`^[A-Za-z0-9_][A-Za-z0-9._-]{0,127}$`)
-
-// ErrInvalidID is returned when a session id is not a plain file name.
-var ErrInvalidID = errors.New("session id is not a plain name")
-
-func checkID(sessionID string) error {
-	if !idPattern.MatchString(sessionID) {
-		return fmt.Errorf("%w: %q", ErrInvalidID, sessionID)
-	}
-	return nil
-}
-
 // Append writes entry as a single JSON line to sessionsDir/{sessionID}.jsonl.
-// The open does not follow a final symlink.
 func Append(sessionsDir, sessionID string, entry Entry) error {
-	if err := checkID(sessionID); err != nil {
-		return err
-	}
-	// Opened through an os.Root on the sessions dir's parent (the brain dir),
-	// so a sessions dir swapped for a symlink after the check below can
-	// redirect the log only inside that parent, never outside it (#173; the
-	// in-brain swap is the #167 residual).
-	parentDir, name := filepath.Dir(sessionsDir), filepath.Base(sessionsDir)
-	if err := os.MkdirAll(parentDir, 0o755); err != nil {
-		return fmt.Errorf("create sessions parent: %w", err)
-	}
-	root, err := os.OpenRoot(parentDir)
-	if err != nil {
-		return fmt.Errorf("open sessions parent: %w", err)
-	}
-	defer func() { _ = root.Close() }()
-	if err := root.Mkdir(name, 0o755); err != nil && !errors.Is(err, fs.ErrExist) {
+	if err := os.MkdirAll(sessionsDir, 0o755); err != nil {
 		return fmt.Errorf("create sessions dir: %w", err)
 	}
-	// The sessions dir itself must be a real directory, not a symlink that
-	// redirects the log elsewhere (hyperguild#173).
-	if fi, err := root.Lstat(name); err != nil {
-		return fmt.Errorf("stat sessions dir: %w", err)
-	} else if !fi.IsDir() {
-		return fmt.Errorf("sessions dir %s is not a real directory", sessionsDir)
-	}
-	logRel := name + "/" + sessionID + ".jsonl"
-	f, err := root.OpenFile(logRel, os.O_CREATE|os.O_APPEND|os.O_WRONLY|syscall.O_NOFOLLOW|syscall.O_NONBLOCK, 0o644)
+	path := filepath.Join(sessionsDir, sessionID+".jsonl")
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0o644)
 	if err != nil {
 		return fmt.Errorf("open session log: %w", err)
 	}
-	// os.Root follows an in-root final symlink even with O_NOFOLLOW, so
-	// confirm, before writing, that the path is the regular file we opened.
-	hfi, herr := f.Stat()
-	lfi, lerr := root.Lstat(logRel)
-	if herr != nil || lerr != nil || !lfi.Mode().IsRegular() || !os.SameFile(lfi, hfi) {
-		_ = f.Close()
-		return fmt.Errorf("session log %s is not a regular file", logRel)
-	}
 
 	line, err := json.Marshal(entry)
 	if err != nil {
@@ -119,9 +70,6 @@ func Append(sessionsDir, sessionID string, entry Entry) error {
 
 // Read returns all entries for sessionID. Returns empty slice if no log exists.
 func Read(sessionsDir, sessionID string) ([]Entry, error) {
-	if err := checkID(sessionID); err != nil {
-		return nil, err
-	}
 	path := filepath.Join(sessionsDir, sessionID+".jsonl")
 	f, err := os.Open(path)
 	if errors.Is(err, fs.ErrNotExist) {

ingestion/internal/startupretry/startupretry.go

@@ -0,0 +1,75 @@
+// Package startupretry retries a startup dependency that may not be serving
+// yet, instead of exiting on its first failure.
+//
+// It exists for the cold-boot ordering race (#83): on a cluster restart the
+// ingestion pod can reach OIDC discovery before dex is answering, gets a 502
+// from ingress, and dies — after having already connected postgres, backfilled
+// the graph and ingested session batches, all of which the restart redoes.
+// Nothing is misconfigured in that scenario; the pod simply started first.
+//
+// The budget is bounded on purpose. Retrying forever would turn a genuine
+// misconfiguration (wrong issuer URL, bad audience) into a process that looks
+// healthy and never serves, which is harder to diagnose than a crash loop.
+package startupretry
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// Policy bounds the retry: at most Attempts calls, with the delay doubling
+// from Base and capped at Max.
+type Policy struct {
+	Attempts int           // total calls, including the first; < 1 means 1
+	Base     time.Duration // delay before the second attempt
+	Max      time.Duration // ceiling for the doubling delay
+}
+
+// Do calls fn until it succeeds, the attempt budget is spent, or ctx ends.
+//
+// The returned error wraps the last failure, so callers keep the diagnosis
+// they would have had without the retry.
+func Do[T any](ctx context.Context, p Policy, fn func(context.Context) (T, error)) (T, error) {
+	var zero T
+
+	attempts := p.Attempts
+	if attempts < 1 {
+		attempts = 1
+	}
+
+	delay := p.Base
+	var lastErr error
+
+	for i := range attempts {
+		if err := ctx.Err(); err != nil {
+			return zero, fmt.Errorf("startupretry: %w", err)
+		}
+
+		v, err := fn(ctx)
+		if err == nil {
+			return v, nil
+		}
+		lastErr = err
+
+		if i == attempts-1 {
+			break
+		}
+
+		if delay <= 0 {
+			delay = time.Second
+		}
+		if p.Max > 0 && delay > p.Max {
+			delay = p.Max
+		}
+
+		select {
+		case <-ctx.Done():
+			return zero, fmt.Errorf("startupretry: %w", ctx.Err())
+		case <-time.After(delay):
+		}
+		delay *= 2
+	}
+
+	return zero, fmt.Errorf("startupretry: gave up after %d attempts: %w", attempts, lastErr)
+}

ingestion/internal/startupretry/startupretry_test.go

@@ -0,0 +1,142 @@
+// ingestion/internal/startupretry/startupretry_test.go
+package startupretry
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+)
+
+func fastPolicy(attempts int) Policy {
+	return Policy{Attempts: attempts, Base: time.Millisecond, Max: 2 * time.Millisecond}
+}
+
+func TestDo_ReturnsImmediatelyOnFirstSuccess(t *testing.T) {
+	calls := 0
+	got, err := Do(context.Background(), fastPolicy(5), func(context.Context) (string, error) {
+		calls++
+		return "ready", nil
+	})
+	if err != nil {
+		t.Fatalf("Do: %v", err)
+	}
+	if got != "ready" {
+		t.Errorf("got %q, want %q", got, "ready")
+	}
+	if calls != 1 {
+		t.Errorf("calls = %d, want 1", calls)
+	}
+}
+
+func TestDo_SurvivesTransientFailuresThenSucceeds(t *testing.T) {
+	// The observed cold-boot race: dex is not serving yet, ingress answers
+	// 502 for the first few attempts, then discovery works.
+	calls := 0
+	got, err := Do(context.Background(), fastPolicy(5), func(context.Context) (string, error) {
+		calls++
+		if calls < 4 {
+			return "", errors.New("oidc discovery: status 502")
+		}
+		return "ready", nil
+	})
+	if err != nil {
+		t.Fatalf("Do returned %v — a transient 502 must not be fatal", err)
+	}
+	if got != "ready" {
+		t.Errorf("got %q, want %q", got, "ready")
+	}
+	if calls != 4 {
+		t.Errorf("calls = %d, want 4", calls)
+	}
+}
+
+func TestDo_GivesUpAfterTheAttemptBudgetAndReportsTheLastError(t *testing.T) {
+	// A genuinely broken issuer must still fail — retrying forever would turn
+	// a config error into a silent hang, which is worse than crash-looping.
+	last := errors.New("oidc discovery: status 404")
+	calls := 0
+
+	_, err := Do(context.Background(), fastPolicy(3), func(context.Context) (string, error) {
+		calls++
+		return "", last
+	})
+
+	if !errors.Is(err, last) {
+		t.Fatalf("err = %v, want it to wrap the last failure", err)
+	}
+	if calls != 3 {
+		t.Errorf("calls = %d, want 3 (the attempt budget)", calls)
+	}
+}
+
+func TestDo_StopsPromptlyWhenTheContextIsCancelled(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	calls := 0
+
+	done := make(chan struct{})
+	var err error
+	go func() {
+		defer close(done)
+		_, err = Do(ctx, Policy{Attempts: 100, Base: 50 * time.Millisecond, Max: time.Second},
+			func(context.Context) (string, error) {
+				calls++
+				if calls == 1 {
+					cancel()
+				}
+				return "", errors.New("still down")
+			})
+	}()
+
+	select {
+	case <-done:
+	case <-time.After(2 * time.Second):
+		t.Fatal("Do did not return after context cancellation")
+	}
+	if !errors.Is(err, context.Canceled) {
+		t.Errorf("err = %v, want context.Canceled", err)
+	}
+}
+
+func TestDo_BacksOffAndIsCappedByMax(t *testing.T) {
+	var delays []time.Duration
+	p := Policy{Attempts: 5, Base: 10 * time.Millisecond, Max: 25 * time.Millisecond}
+
+	last := time.Now()
+	_, _ = Do(context.Background(), p, func(context.Context) (string, error) {
+		now := time.Now()
+		delays = append(delays, now.Sub(last))
+		last = now
+		return "", errors.New("down")
+	})
+
+	// delays[0] is the first call (no wait); the rest are the sleeps.
+	if len(delays) != 5 {
+		t.Fatalf("attempts = %d, want 5", len(delays))
+	}
+	if delays[1] >= delays[2] {
+		t.Errorf("backoff is not growing: %v then %v", delays[1], delays[2])
+	}
+	for i, d := range delays[1:] {
+		if d > 2*p.Max {
+			t.Errorf("delay %d = %v, exceeds the Max cap %v with slack", i+1, d, p.Max)
+		}
+	}
+}
+
+func TestPolicy_ZeroValueStillMakesOneAttempt(t *testing.T) {
+	// A caller that forgets to configure the policy must not silently get a
+	// no-op that returns a nil validator and a nil error.
+	calls := 0
+	_, err := Do(context.Background(), Policy{}, func(context.Context) (string, error) {
+		calls++
+		return "", errors.New("down")
+	})
+
+	if calls != 1 {
+		t.Errorf("calls = %d, want 1", calls)
+	}
+	if err == nil {
+		t.Error("err = nil, want the failure surfaced")
+	}
+}

ingestion/internal/symlinkguard/symlinkguard.go

@@ -1,357 +0,0 @@
-// Package symlinkguard is the hyperguild#157 tripwire. The brain directory is
-// a Syncthing sendreceive folder and Syncthing syncs symlinks; several brain
-// readers (search, vectorstore, context, graph) follow a symlink out of the
-// brain and would index or return whatever it points to. Until every reader
-// reads through an os.Root, a symlink inside the brain, or a directory the
-// scan cannot read (which could hide one), is an incident: the server refuses
-// to start on one (main), and Watch reports one that appears while it runs.
-package symlinkguard
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"io/fs"
-	"log/slog"
-	"os"
-	"path/filepath"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// shutdownFlushTimeout bounds the final flush when Watch stops.
-var shutdownFlushTimeout = 5 * time.Second
-
-// DefaultInterval is used when Watch is given a non-positive interval.
-const DefaultInterval = 30 * time.Second
-
-// Alert bounds (PR #160 review): the planter chooses the paths, so neither an
-// alert's size nor the queue may grow with what was planted.
-const (
-	maxPathsPerAlert = 10 // further paths are counted, not listed
-	maxPending       = 5  // queued alerts; the rest become one summary
-)
-
-// Notifier is the out-of-band alert sink (audit.Notifier satisfies it).
-type Notifier interface {
-	Notify(ctx context.Context, msg string) error
-}
-
-// Result is what a scan found: symlinks, and directories it could not read
-// (each of which could hide a symlink). Paths are brain-relative.
-type Result struct {
-	Symlinks   []string
-	Unreadable []string
-}
-
-// Clean reports whether the scan found nothing to act on.
-func (r Result) Clean() bool { return len(r.Symlinks) == 0 && len(r.Unreadable) == 0 }
-
-// String describes the findings for a log line or alert. Paths are quoted, so
-// a name containing a newline cannot blur two findings together.
-func (r Result) String() string {
-	q := r.quoted
-	var parts []string
-	if len(r.Symlinks) > 0 {
-		parts = append(parts, fmt.Sprintf("%d symlink(s): %s", len(r.Symlinks), q(r.Symlinks)))
-	}
-	if len(r.Unreadable) > 0 {
-		parts = append(parts, fmt.Sprintf("%d unreadable dir(s): %s", len(r.Unreadable), q(r.Unreadable)))
-	}
-	return strings.Join(parts, "; ")
-}
-
-// quoted joins at most maxPathsPerAlert paths, each strconv-quoted, and
-// counts the rest.
-func (Result) quoted(xs []string) string {
-	shown := xs
-	if len(shown) > maxPathsPerAlert {
-		shown = shown[:maxPathsPerAlert]
-	}
-	out := make([]string, len(shown))
-	for i, x := range shown {
-		out[i] = strconv.Quote(x)
-	}
-	s := strings.Join(out, ", ")
-	if extra := len(xs) - len(shown); extra > 0 {
-		s += fmt.Sprintf(" and %d more", extra)
-	}
-	return s
-}
-
-// Scan walks the brain dir and reports every symlink in it and every
-// directory it could not read, continuing past both. Only the ROOT .git is
-// skipped (it is brain-sync's, and no reader walks it); a nested .git is
-// scanned like any other directory. brainDir itself may be a symlink (a
-// volume mount); it is resolved first. The error is non-nil when the root
-// cannot be resolved (wrapping os.ErrNotExist when it is missing) or cannot be
-// listed.
-func Scan(brainDir string) (Result, error) {
-	root, err := filepath.EvalSymlinks(brainDir)
-	if err != nil {
-		return Result{}, fmt.Errorf("resolve brain dir: %w", err)
-	}
-	var r Result
-	rootGit := filepath.Join(root, ".git")
-	walkErr := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
-		rel, _ := filepath.Rel(root, p)
-		rel = filepath.ToSlash(rel)
-		if err != nil {
-			if p == root {
-				return err
-			}
-			r.Unreadable = append(r.Unreadable, rel)
-			if d != nil && d.IsDir() {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-		if d.IsDir() && p == rootGit {
-			return filepath.SkipDir
-		}
-		if d.Type()&os.ModeSymlink != 0 {
-			r.Symlinks = append(r.Symlinks, rel)
-		}
-		return nil
-	})
-	sort.Strings(r.Symlinks)
-	sort.Strings(r.Unreadable)
-	if walkErr != nil {
-		// Only the root's own error reaches here (deeper errors are recorded
-		// as Unreadable). A root that cannot be listed cannot be shown clean
-		// (PR #159 round 2: discarding this reported clean while search
-		// served a planted symlink).
-		return r, fmt.Errorf("scan brain dir: %w", walkErr)
-	}
-	return r, nil
-}
-
-// Watch rescans every interval (DefaultInterval if non-positive) until ctx
-// ends. Every symlink found is removed (the link, never its target:
-// hyperguild#157 decision), so one is readable for at most one interval.
-// Each removal is an alert; a persistent finding (a link it could not remove,
-// an unreadable dir, a scan error) alerts once per distinct state. Alerts
-// queue until Notify succeeds (see alertQueue): an outage delays them, and
-// any that do not fit the bounded queue, or are undeliverable, are counted in
-// a summary that is never dropped, so every incident is delivered or counted.
-//
-// Delivery runs in its own goroutine (hyperguild#164): a hung notifier, with
-// a full queue, blocked one flush for several notify timeouts, and while the
-// scan waited on it a planted link stayed readable for several intervals.
-// The scan hands alerts over without blocking; any that do not fit are
-// counted in the summary. When ctx ends, Watch returns after a final flush
-// of what was handed over (bounded by shutdownFlushTimeout); alerts that
-// flush cannot deliver are counted in one error log line instead. That
-// shutdown path only runs for a caller that cancels ctx: cmd/server passes
-// context.Background(), so in production the flush on handoff is what keeps
-// alerts from waiting on a restart.
-func Watch(ctx context.Context, brainDir string, interval time.Duration, n Notifier) {
-	if interval <= 0 {
-		interval = DefaultInterval
-	}
-	t := time.NewTicker(interval)
-	defer t.Stop()
-	alerts := make(chan string, maxPending)
-	var overflow atomic.Int64
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() { defer wg.Done(); deliver(ctx, interval, n, alerts, &overflow) }()
-	// The scan is the only sender: closing alerts tells deliver to drain and
-	// flush once more, and Watch returns only after it has.
-	defer func() { close(alerts); wg.Wait() }()
-	q := alertSender{alerts: alerts, overflow: &overflow}
-	reported := ""
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-t.C:
-		}
-		r, err := Scan(brainDir)
-		key := ""
-		if err != nil {
-			key = "cannot scan the brain dir: " + err.Error()
-		} else {
-			removed, failed := removeSymlinks(brainDir, r.Symlinks)
-			if len(removed) > 0 {
-				slog.Error("brain symlink tripwire removed symlinks", "count", len(removed))
-				q.push(fmt.Sprintf("brain symlink tripwire (hyperguild#157): removed %d symlink(s) from the brain dir: %s",
-					len(removed), Result{}.quoted(removed)))
-			}
-			key = Result{Symlinks: failed, Unreadable: r.Unreadable}.String()
-		}
-		if key != reported {
-			reported = key
-			if key != "" {
-				slog.Error("brain symlink tripwire", "finding", key)
-				q.push("brain symlink tripwire (hyperguild#157): " + key +
-					". Readers may follow symlinks out of the brain; fix them.")
-			}
-		}
-	}
-}
-
-// alertSender hands alerts to deliver without ever blocking the scan; an
-// alert that does not fit is counted in overflow, which deliver adds to the
-// summary.
-type alertSender struct {
-	alerts   chan<- string
-	overflow *atomic.Int64
-}
-
-func (s alertSender) push(msg string) {
-	select {
-	case s.alerts <- msg:
-	default:
-		s.overflow.Add(1)
-	}
-}
-
-// deliver owns the alertQueue. It flushes as soon as an alert is handed
-// over, and again every interval while any are pending (outage retries).
-// When alerts is closed (Watch is stopping) it drains it and flushes once
-// more, bounded by shutdownFlushTimeout, so an alert handed over just before
-// shutdown is not lost (PR #180 review). Whatever that flush cannot deliver
-// is logged as one error with its counts, never dropped silently.
-func deliver(ctx context.Context, interval time.Duration, n Notifier, alerts <-chan string, overflow *atomic.Int64) {
-	t := time.NewTicker(interval)
-	defer t.Stop()
-	q := &alertQueue{}
-	// drain moves everything handed over into the queue; it reports false
-	// once alerts is closed.
-	drain := func() bool {
-		defer func() { q.suppressed += int(overflow.Swap(0)) }()
-		for {
-			select {
-			case msg, ok := <-alerts:
-				if !ok {
-					return false
-				}
-				q.push(msg)
-			default:
-				return true
-			}
-		}
-	}
-	for {
-		select {
-		case msg, ok := <-alerts:
-			if ok {
-				q.push(msg)
-				ok = drain()
-			}
-			if !ok {
-				q.suppressed += int(overflow.Swap(0))
-				fctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), shutdownFlushTimeout)
-				q.flush(fctx, n)
-				cancel()
-				if len(q.items) > 0 || q.suppressed > 0 {
-					slog.Error("symlink tripwire alerts not delivered at shutdown",
-						"undelivered", len(q.items), "suppressed", q.suppressed)
-				}
-				return
-			}
-			q.flush(ctx, n)
-		case <-t.C:
-			if !drain() {
-				continue // the closed channel is handled by the case above
-			}
-			q.flush(ctx, n)
-		}
-	}
-}
-
-// alertQueue holds alerts until Notify accepts them. It is bounded (at most
-// maxPending queued) and loses nothing from the record: every overflow and
-// every dropped message increments suppressed, sent as a summary that is
-// retried every tick and never dropped.
-//
-// A message is dropped only when the notifier rejects it permanently (an
-// error with Permanent() == true, e.g. ntfy 413). Every other failure is an
-// outage, and nothing is dropped however long it lasts (PR #160 round 2:
-// dropping after N raw failures lost the only incident of a long outage).
-// Each flush tries every queued message, so one undeliverable message cannot
-// block the others.
-type alertQueue struct {
-	items      []string
-	suppressed int
-}
-
-func (q *alertQueue) push(msg string) {
-	if len(q.items) >= maxPending {
-		q.suppressed++
-		return
-	}
-	q.items = append(q.items, msg)
-}
-
-func (q *alertQueue) flush(ctx context.Context, n Notifier) {
-	if n == nil {
-		q.items, q.suppressed = nil, 0
-		return
-	}
-	kept := q.items[:0]
-	for _, msg := range q.items {
-		err := n.Notify(ctx, msg)
-		switch {
-		case err == nil:
-		case permanent(err):
-			slog.Error("symlink tripwire alert rejected permanently; counted in the summary", "err", err)
-			q.suppressed++
-		default:
-			slog.Warn("symlink tripwire notify failed; will retry", "err", err)
-			kept = append(kept, msg)
-		}
-	}
-	q.items = kept
-	if q.suppressed > 0 {
-		msg := fmt.Sprintf("brain symlink tripwire (hyperguild#157): %d further alert(s) were suppressed or undeliverable; check the ingestion logs", q.suppressed)
-		if err := n.Notify(ctx, msg); err == nil {
-			q.suppressed = 0
-		}
-	}
-}
-
-// permanent reports whether err says the message itself can never be sent.
-func permanent(err error) bool {
-	var p interface{ Permanent() bool }
-	return errors.As(err, &p) && p.Permanent()
-}
-
-// removeSymlinks unlinks each brain-relative symlink through an os.Root on
-// the brain dir, after re-checking it is still a symlink. Removing a symlink
-// never touches its target. It returns what was removed and what was not.
-func removeSymlinks(brainDir string, rels []string) (removed, failed []string) {
-	if len(rels) == 0 {
-		return nil, nil
-	}
-	resolved, err := filepath.EvalSymlinks(brainDir)
-	if err != nil {
-		return nil, rels
-	}
-	root, err := os.OpenRoot(resolved)
-	if err != nil {
-		return nil, rels
-	}
-	defer func() { _ = root.Close() }()
-	for _, rel := range rels {
-		fi, err := root.Lstat(rel)
-		if err != nil || fi.Mode()&os.ModeSymlink == 0 {
-			failed = append(failed, rel)
-			continue
-		}
-		// root.Remove, not os.RemoveAll: if the link is swapped for a
-		// non-empty directory after the Lstat, Remove refuses rather than
-		// deleting it recursively, and it cannot act outside the root.
-		if err := root.Remove(rel); err != nil {
-			failed = append(failed, rel)
-			continue
-		}
-		removed = append(removed, rel)
-	}
-	return removed, failed
-}

ingestion/internal/symlinkguard/symlinkguard_test.go

@@ -1,774 +0,0 @@
-package symlinkguard
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"log/slog"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// hyperguild#157: the brain dir is a Syncthing sendreceive folder and
-// Syncthing syncs symlinks; several readers follow them out of the brain.
-// Until every reader goes through an os.Root, a symlink anywhere in the brain,
-// or a directory the scan cannot read (which could hide one), is an incident.
-
-func TestScanReportsSymlinksAtEveryDepthIncludingNestedGit(t *testing.T) {
-	brain := t.TempDir()
-	outside := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki", "w", "facts", ".git"), 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, ".git", "objects"), 0o755))
-	require.NoError(t, os.Symlink(filepath.Join(outside, "f"), filepath.Join(brain, "wiki", "w", "facts", "leak.md")))
-	require.NoError(t, os.Symlink(outside, filepath.Join(brain, "wiki", "dirlink")))
-	// PR #159 review: only the ROOT .git is skipped; a nested .git is not
-	// special to the brain readers, which walk into it.
-	require.NoError(t, os.Symlink(filepath.Join(outside, "g"), filepath.Join(brain, "wiki", "w", "facts", ".git", "leak.md")))
-	require.NoError(t, os.Symlink(outside, filepath.Join(brain, ".git", "objects", "alt")))
-
-	r, err := Scan(brain)
-	require.NoError(t, err)
-	assert.ElementsMatch(t, []string{"wiki/w/facts/leak.md", "wiki/dirlink", "wiki/w/facts/.git/leak.md"}, r.Symlinks)
-	assert.Empty(t, r.Unreadable)
-}
-
-// PR #159 review: WalkDir stopped at the first unreadable directory and the
-// startup check passed, while search (which keeps walking) served a planted
-// symlink. Scan now records the unreadable dir and keeps going.
-func TestScanReportsUnreadableDirsAndKeepsWalkingPastThem(t *testing.T) {
-	if os.Geteuid() == 0 {
-		t.Skip("root reads mode-000 directories")
-	}
-	brain := t.TempDir()
-	locked := filepath.Join(brain, "aaa")
-	require.NoError(t, os.MkdirAll(locked, 0o755))
-	require.NoError(t, os.Chmod(locked, 0o000))
-	t.Cleanup(func() { _ = os.Chmod(locked, 0o755) })
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "zzz-planted")))
-
-	r, err := Scan(brain)
-	require.NoError(t, err)
-	assert.Equal(t, []string{"aaa"}, r.Unreadable)
-	assert.Equal(t, []string{"zzz-planted"}, r.Symlinks, "the walk continues past the unreadable dir")
-}
-
-func TestScanResolvesASymlinkedRootAndReportsSymlinkedEntriesInsideIt(t *testing.T) {
-	real := t.TempDir()
-	link := filepath.Join(t.TempDir(), "brain")
-	require.NoError(t, os.Symlink(real, link))
-	require.NoError(t, os.WriteFile(filepath.Join(real, "n.md"), []byte("x"), 0o644))
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(real, "inner")))
-	r, err := Scan(link)
-	require.NoError(t, err)
-	assert.Equal(t, []string{"inner"}, r.Symlinks)
-}
-
-func TestScanOfAMissingRootIsErrNotExist(t *testing.T) {
-	_, err := Scan(filepath.Join(t.TempDir(), "nope"))
-	assert.True(t, errors.Is(err, os.ErrNotExist), "got %v", err)
-}
-
-type recNotifier struct {
-	mu   sync.Mutex
-	msgs []string
-	fail int // fail the first N calls
-}
-
-func (r *recNotifier) Notify(_ context.Context, m string) error {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.msgs = append(r.msgs, m)
-	if r.fail > 0 {
-		r.fail--
-		return errors.New("ntfy down")
-	}
-	return nil
-}
-
-func (r *recNotifier) count() int { r.mu.Lock(); defer r.mu.Unlock(); return len(r.msgs) }
-
-func TestWatchNotifiesOncePerDistinctSetAndAgainForANewSet(t *testing.T) {
-	brain := t.TempDir()
-	n := &recNotifier{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 10*time.Millisecond, n)
-
-	time.Sleep(50 * time.Millisecond)
-	assert.Zero(t, n.count(), "a clean brain raises nothing")
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "first")))
-	require.Eventually(t, func() bool { return n.count() == 1 }, 2*time.Second, 10*time.Millisecond)
-	time.Sleep(60 * time.Millisecond)
-	assert.Equal(t, 1, n.count(), "the same set is reported once, not every tick")
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "second")))
-	require.Eventually(t, func() bool { return n.count() == 2 }, 2*time.Second, 10*time.Millisecond)
-}
-
-// PR #159 review: last was recorded before Notify, so an alert lost to an
-// ntfy outage was never retried while the symlink stayed.
-func TestWatchRetriesAnAlertThatFailedToSend(t *testing.T) {
-	brain := t.TempDir()
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "planted")))
-	n := &recNotifier{fail: 2}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 10*time.Millisecond, n)
-	require.Eventually(t, func() bool { return n.count() == 3 }, 2*time.Second, 10*time.Millisecond)
-	time.Sleep(60 * time.Millisecond)
-	assert.Equal(t, 3, n.count(), "after one successful send, no more")
-}
-
-func TestWatchAlertsOnAnUnreadableDir(t *testing.T) {
-	if os.Geteuid() == 0 {
-		t.Skip("root reads mode-000 directories")
-	}
-	brain := t.TempDir()
-	locked := filepath.Join(brain, "locked")
-	require.NoError(t, os.MkdirAll(locked, 0o755))
-	require.NoError(t, os.Chmod(locked, 0o000))
-	t.Cleanup(func() { _ = os.Chmod(locked, 0o755) })
-	n := &recNotifier{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 10*time.Millisecond, n)
-	require.Eventually(t, func() bool { return n.count() == 1 }, 2*time.Second, 10*time.Millisecond)
-	assert.Contains(t, n.msgs[0], "locked")
-}
-
-// PR #159 review: a non-positive interval panicked time.NewTicker inside the
-// goroutine and crashlooped the server.
-func TestWatchToleratesANonPositiveInterval(t *testing.T) {
-	brain := t.TempDir()
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan struct{})
-	go func() { Watch(ctx, brain, 0, nil); close(done) }()
-	cancel()
-	select {
-	case <-done:
-	case <-time.After(2 * time.Second):
-		t.Fatal("Watch did not return on cancel")
-	}
-}
-
-// PR #159 round 2: a brain root that can be entered but not listed (mode
-// 0100) made WalkDir fail at the root; the error was discarded and Scan
-// reported clean, while search (which goes straight into wiki/) still served
-// a planted symlink. A root that cannot be listed is now an error.
-func TestScanOfAnUnlistableRootIsAnError(t *testing.T) {
-	if os.Geteuid() == 0 {
-		t.Skip("root lists mode-0100 directories")
-	}
-	brain := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki"), 0o755))
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "wiki", "leak.md")))
-	require.NoError(t, os.Chmod(brain, 0o100))
-	t.Cleanup(func() { _ = os.Chmod(brain, 0o755) })
-	_, err := Scan(brain)
-	require.Error(t, err)
-	assert.False(t, errors.Is(err, os.ErrNotExist), "an unlistable root is not a missing root")
-}
-
-// The same set that disappears and comes back is reported again.
-func TestWatchReportsASetAgainAfterItWasCleared(t *testing.T) {
-	brain := t.TempDir()
-	link := filepath.Join(brain, "planted")
-	n := &recNotifier{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 10*time.Millisecond, n)
-	require.NoError(t, os.Symlink(t.TempDir(), link))
-	require.Eventually(t, func() bool { return n.count() == 1 }, 2*time.Second, 10*time.Millisecond)
-	// The tripwire removed it; planting it again is a new event.
-	require.Eventually(t, func() bool { _, err := os.Lstat(link); return os.IsNotExist(err) }, 2*time.Second, 10*time.Millisecond)
-	require.NoError(t, os.Symlink(t.TempDir(), link))
-	require.Eventually(t, func() bool { return n.count() == 2 }, 2*time.Second, 10*time.Millisecond)
-}
-
-// hyperguild#157 decision: the runtime tripwire removes a symlink it finds
-// (the link, never its target), so it is readable for at most one interval
-// instead of until a human acts, and the alert says what was removed.
-func TestWatchRemovesAnOutsideFileLinkButNotItsTargetOrRegularFiles(t *testing.T) {
-	brain := t.TempDir()
-	outside := filepath.Join(t.TempDir(), "target.md")
-	require.NoError(t, os.WriteFile(outside, []byte("keep me"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki"), 0o755))
-	link := filepath.Join(brain, "wiki", "leak.md")
-	require.NoError(t, os.Symlink(outside, link))
-	regular := filepath.Join(brain, "wiki", "note.md")
-	require.NoError(t, os.WriteFile(regular, []byte("note"), 0o644))
-
-	n := &recNotifier{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 10*time.Millisecond, n)
-
-	require.Eventually(t, func() bool {
-		_, err := os.Lstat(link)
-		return os.IsNotExist(err)
-	}, 2*time.Second, 10*time.Millisecond, "the symlink is removed")
-	require.Eventually(t, func() bool { return n.count() >= 1 }, 2*time.Second, 10*time.Millisecond)
-	b, err := os.ReadFile(outside)
-	require.NoError(t, err)
-	assert.Equal(t, "keep me", string(b), "the target is untouched")
-	b, err = os.ReadFile(regular)
-	require.NoError(t, err)
-	assert.Equal(t, "note", string(b), "regular files are untouched")
-	n.mu.Lock()
-	defer n.mu.Unlock()
-	assert.Contains(t, n.msgs[0], "removed")
-	assert.Contains(t, n.msgs[0], "wiki/leak.md")
-}
-
-func TestDefaultIntervalIsThirtySeconds(t *testing.T) {
-	assert.Equal(t, 30*time.Second, DefaultInterval)
-}
-
-// PR #160 review: the Lstat re-check and the os.Root confinement in
-// removeSymlinks had no test. Anything that is not a symlink inside the brain
-// is reported failed and nothing is deleted.
-func TestRemoveSymlinksRefusesNonSymlinksEscapesAndPathsThroughLinks(t *testing.T) {
-	brain := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki", "real"), 0o755))
-	regular := filepath.Join(brain, "wiki", "note.md")
-	require.NoError(t, os.WriteFile(regular, []byte("note"), 0o644))
-	inLinked := filepath.Join(brain, "wiki", "real", "x.md")
-	require.NoError(t, os.WriteFile(inLinked, []byte("x"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join(brain, "wiki", "real"), filepath.Join(brain, "wiki", "linkdir")))
-	outside := filepath.Join(filepath.Dir(brain), "outside-157.md")
-	require.NoError(t, os.WriteFile(outside, []byte("o"), 0o644))
-	t.Cleanup(func() { _ = os.Remove(outside) })
-
-	removed, failed := removeSymlinks(brain, []string{
-		"wiki/note.md", "wiki/linkdir/x.md", "../outside-157.md", "wiki/missing.md",
-	})
-	assert.Empty(t, removed)
-	assert.ElementsMatch(t, []string{"wiki/note.md", "wiki/linkdir/x.md", "../outside-157.md", "wiki/missing.md"}, failed)
-	for _, p := range []string{regular, inLinked, outside} {
-		_, err := os.Stat(p)
-		assert.NoError(t, err, "%s must not be deleted", p)
-	}
-}
-
-// Dir targets and in-brain targets survive too, not only an outside file.
-func TestWatchRemovesDirAndInBrainLinksButNotTheirTargets(t *testing.T) {
-	brain := t.TempDir()
-	outsideDir := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(outsideDir, "keep.md"), []byte("keep"), 0o644))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki"), 0o755))
-	inBrain := filepath.Join(brain, "wiki", "target.md")
-	require.NoError(t, os.WriteFile(inBrain, []byte("t"), 0o644))
-	require.NoError(t, os.Symlink(outsideDir, filepath.Join(brain, "wiki", "dirlink")))
-	require.NoError(t, os.Symlink(inBrain, filepath.Join(brain, "wiki", "inlink.md")))
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 10*time.Millisecond, nil)
-	require.Eventually(t, func() bool {
-		r, err := Scan(brain)
-		return err == nil && len(r.Symlinks) == 0
-	}, 2*time.Second, 10*time.Millisecond)
-	for _, p := range []string{filepath.Join(outsideDir, "keep.md"), inBrain} {
-		_, err := os.Stat(p)
-		assert.NoError(t, err, "%s must survive", p)
-	}
-}
-
-// PR #160 review: the planter chooses the paths. An alert names at most
-// maxPathsPerAlert of them and counts the rest, so its size stays bounded.
-func TestWatchAlertNamesBoundedPathsAndCountsTheRest(t *testing.T) {
-	brain := t.TempDir()
-	for i := 0; i < 50; i++ {
-		require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, strings.Repeat("n", 100)+strconv.Itoa(i))))
-	}
-	n := &recNotifier{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 10*time.Millisecond, n)
-	require.Eventually(t, func() bool { return n.count() >= 1 }, 2*time.Second, 10*time.Millisecond)
-	n.mu.Lock()
-	msg := n.msgs[0]
-	n.mu.Unlock()
-	assert.Contains(t, msg, "removed 50 symlink(s)")
-	assert.Contains(t, msg, "and 40 more")
-	assert.Less(t, len(msg), 2500, "alert size is bounded regardless of how many links were planted")
-}
-
-// rejectNotifier refuses every message containing a marker, forever.
-type rejectNotifier struct {
-	recNotifier
-	reject string
-}
-
-// permanentErr is a rejection the notifier says can never succeed (like ntfy 413).
-type permanentErr struct{}
-
-func (permanentErr) Error() string   { return "413 payload too large" }
-func (permanentErr) Permanent() bool { return true }
-
-func (r *rejectNotifier) Notify(ctx context.Context, m string) error {
-	if strings.Contains(m, r.reject) {
-		r.mu.Lock()
-		r.msgs = append(r.msgs, "REJECTED")
-		r.mu.Unlock()
-		return permanentErr{}
-	}
-	return r.recNotifier.Notify(ctx, m)
-}
-
-// PR #160 review: one message the server will never accept blocked every
-// later alert forever (head-of-line). It is dropped after maxAttempts.
-func TestWatchDropsAMessageThatNeverSendsSoLaterAlertsFlow(t *testing.T) {
-	brain := t.TempDir()
-	n := &rejectNotifier{reject: "POISON"}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 10*time.Millisecond, n)
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "POISON")))
-	time.Sleep(30 * time.Millisecond)
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "later")))
-	require.Eventually(t, func() bool {
-		n.mu.Lock()
-		defer n.mu.Unlock()
-		for _, m := range n.msgs {
-			if strings.Contains(m, "later") {
-				return true
-			}
-		}
-		return false
-	}, 3*time.Second, 10*time.Millisecond, "a later alert is delivered despite a poison message")
-}
-
-// toggleNotifier fails while down is set. Like the real audit.NtfyNotifier
-// (http.NewRequestWithContext), it also fails, without recording, when its
-// ctx is already done (PR #180 round 2: notifiers that ignored ctx let a
-// final flush on the cancelled ctx pass).
-type toggleNotifier struct {
-	recNotifier
-	down atomic.Bool
-}
-
-func (r *toggleNotifier) Notify(ctx context.Context, m string) error {
-	if err := ctx.Err(); err != nil {
-		return err
-	}
-	if r.down.Load() {
-		return errors.New("ntfy down")
-	}
-	return r.recNotifier.Notify(ctx, m)
-}
-
-// PR #160 review: an outage queued one message per removal, unbounded. The
-// queue holds at most maxPending messages; the rest become one summary.
-func TestWatchQueueIsBoundedDuringAnOutage(t *testing.T) {
-	brain := t.TempDir()
-	n := &toggleNotifier{}
-	n.down.Store(true)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 5*time.Millisecond, n)
-	for i := 0; i < 30; i++ {
-		link := filepath.Join(brain, "p"+strconv.Itoa(i))
-		require.NoError(t, os.Symlink(t.TempDir(), link))
-		require.Eventually(t, func() bool { _, err := os.Lstat(link); return os.IsNotExist(err) }, 2*time.Second, 2*time.Millisecond)
-	}
-	n.down.Store(false)
-	require.Eventually(t, func() bool { return n.count() >= 1 }, 2*time.Second, 5*time.Millisecond)
-	time.Sleep(100 * time.Millisecond)
-	assert.LessOrEqual(t, n.count(), maxPending+1, "queued alerts plus at most one suppression summary")
-	n.mu.Lock()
-	defer n.mu.Unlock()
-	found := false
-	for _, m := range n.msgs {
-		if strings.Contains(m, "suppressed") {
-			found = true
-		}
-	}
-	assert.True(t, found, "suppressed alerts are counted in a summary")
-}
-
-// Within the bound, every alert queued during an outage is delivered after
-// it, each naming its own removal (PR #160 review: truncating the queue after
-// the first send stayed green).
-func TestWatchDeliversEveryQueuedAlertAfterAShortOutage(t *testing.T) {
-	brain := t.TempDir()
-	n := &toggleNotifier{}
-	n.down.Store(true)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 5*time.Millisecond, n)
-	for _, name := range []string{"qa", "qb", "qc"} {
-		link := filepath.Join(brain, name)
-		require.NoError(t, os.Symlink(t.TempDir(), link))
-		require.Eventually(t, func() bool { _, err := os.Lstat(link); return os.IsNotExist(err) }, 2*time.Second, 2*time.Millisecond)
-	}
-	n.down.Store(false)
-	require.Eventually(t, func() bool { return n.count() == 3 }, 2*time.Second, 5*time.Millisecond)
-	n.mu.Lock()
-	defer n.mu.Unlock()
-	for i, name := range []string{"qa", "qb", "qc"} {
-		assert.Contains(t, n.msgs[i], strconv.Quote(name))
-	}
-}
-
-// PR #160 round 2: dropping after N failures could not tell a poison message
-// from an outage, so a 15-minute outage silently lost the only incident. A
-// message is only dropped when it keeps failing while others send; through
-// an outage nothing is dropped, however long.
-func TestWatchLosesNoAlertThroughALongOutage(t *testing.T) {
-	brain := t.TempDir()
-	n := &toggleNotifier{}
-	n.down.Store(true)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 2*time.Millisecond, n)
-	link := filepath.Join(brain, "only-incident")
-	require.NoError(t, os.Symlink(t.TempDir(), link))
-	require.Eventually(t, func() bool { _, err := os.Lstat(link); return os.IsNotExist(err) }, 2*time.Second, 2*time.Millisecond)
-	time.Sleep(200 * time.Millisecond) // ~100 ticks of outage, far past any attempt limit
-	n.down.Store(false)
-	require.Eventually(t, func() bool { return n.count() >= 1 }, 2*time.Second, 5*time.Millisecond)
-	n.mu.Lock()
-	defer n.mu.Unlock()
-	assert.Contains(t, n.msgs[0], strconv.Quote("only-incident"))
-}
-
-// Every removal is either delivered or counted in the suppression summary:
-// none disappears from the record (round 2: 74 of 300 were in neither).
-func TestWatchAccountsForEveryRemovalDuringAnOutage(t *testing.T) {
-	brain := t.TempDir()
-	n := &toggleNotifier{}
-	n.down.Store(true)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 2*time.Millisecond, n)
-	const plants = 25
-	for i := 0; i < plants; i++ {
-		link := filepath.Join(brain, "acct"+strconv.Itoa(i))
-		require.NoError(t, os.Symlink(t.TempDir(), link))
-		require.Eventually(t, func() bool { _, err := os.Lstat(link); return os.IsNotExist(err) }, 2*time.Second, 1*time.Millisecond)
-	}
-	n.down.Store(false)
-	require.Eventually(t, func() bool {
-		n.mu.Lock()
-		defer n.mu.Unlock()
-		for _, m := range n.msgs {
-			if strings.Contains(m, "suppressed") {
-				return true
-			}
-		}
-		return false
-	}, 2*time.Second, 5*time.Millisecond)
-	time.Sleep(50 * time.Millisecond)
-	n.mu.Lock()
-	defer n.mu.Unlock()
-	delivered, counted := 0, 0
-	for _, m := range n.msgs {
-		if strings.Contains(m, "removed 1 symlink(s)") {
-			delivered++
-		}
-		if i := strings.Index(m, "): "); i >= 0 && strings.Contains(m, "suppressed") {
-			_, _ = fmt.Sscanf(m[i+3:], "%d", &counted)
-		}
-	}
-	assert.Equal(t, plants, delivered+counted, "delivered %d + counted %d must equal %d removals", delivered, counted, plants)
-}
-
-// A poison message is still dropped (others send while it fails), and the
-// drop is counted in the summary.
-func TestWatchDropsAPoisonMessageAndCountsIt(t *testing.T) {
-	brain := t.TempDir()
-	n := &rejectNotifier{reject: "POISON"}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 5*time.Millisecond, n)
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "POISON")))
-	time.Sleep(20 * time.Millisecond)
-	require.NoError(t, os.Symlink(t.TempDir(), filepath.Join(brain, "fine")))
-	require.Eventually(t, func() bool {
-		n.mu.Lock()
-		defer n.mu.Unlock()
-		for _, m := range n.msgs {
-			if strings.Contains(m, "1 further alert(s)") {
-				return true
-			}
-		}
-		return false
-	}, 3*time.Second, 5*time.Millisecond, "the dropped poison alert is counted in a summary")
-}
-
-// hungNotifier answers every Notify only after latency (or when ctx ends),
-// with an outage error: an ntfy that accepts connections but never responds
-// until its timeout.
-type hungNotifier struct{ latency time.Duration }
-
-func (h hungNotifier) Notify(ctx context.Context, _ string) error {
-	select {
-	case <-time.After(h.latency):
-	case <-ctx.Done():
-	}
-	return errors.New("ntfy timeout")
-}
-
-func waitGone(t *testing.T, link string) {
-	t.Helper()
-	require.Eventually(t, func() bool { _, err := os.Lstat(link); return os.IsNotExist(err) }, 10*time.Second, time.Millisecond)
-}
-
-// hyperguild#164: alerts were flushed in the scan goroutine, so with a hung
-// ntfy and a full queue one flush (6 x notify timeout) delayed the next scan.
-// The notifier here is slower than the interval, as in production (10 s
-// timeout vs 30 s interval with 6 messages), so the alert handoff is full:
-// a scan that waited on it would keep a link for seconds.
-func TestWatchLinkLifetimeStaysNearOneIntervalWithANotifierSlowerThanTheInterval(t *testing.T) {
-	const interval = 100 * time.Millisecond
-	brain := t.TempDir()
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, interval, hungNotifier{latency: 400 * time.Millisecond})
-
-	for i := 0; i < 2*maxPending+3; i++ { // overfill queue and handoff
-		link := filepath.Join(brain, "fill"+strconv.Itoa(i))
-		require.NoError(t, os.Symlink(t.TempDir(), link))
-		waitGone(t, link)
-	}
-	var worst time.Duration
-	for i := 0; i < 6; i++ {
-		link := filepath.Join(brain, "probe"+strconv.Itoa(i))
-		require.NoError(t, os.Symlink(t.TempDir(), link))
-		planted := time.Now()
-		waitGone(t, link)
-		worst = max(worst, time.Since(planted))
-	}
-	assert.LessOrEqual(t, worst, interval+interval/2, "worst link lifetime %v with a hung notifier", worst)
-}
-
-// Review of PR #180: delivery waited for its own tick, about one interval
-// after the removal. An alert is now flushed as soon as it is handed over.
-func TestWatchDeliversARemovalAlertWellWithinOneInterval(t *testing.T) {
-	const interval = 400 * time.Millisecond
-	brain := t.TempDir()
-	n := &recNotifier{}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, interval, n)
-	link := filepath.Join(brain, "prompt")
-	require.NoError(t, os.Symlink(t.TempDir(), link))
-	waitGone(t, link)
-	removed := time.Now()
-	require.Eventually(t, func() bool { return n.count() == 1 }, 2*time.Second, time.Millisecond)
-	assert.Less(t, time.Since(removed), interval/4)
-}
-
-// Review of PR #180: on ctx end, deliver returned without draining what the
-// scan had handed over, so a removal just before shutdown was neither
-// delivered nor counted. Watch now drains and flushes before returning.
-func TestWatchDeliversAnAlertHandedOverJustBeforeShutdown(t *testing.T) {
-	for i := 0; i < 20; i++ {
-		brain := t.TempDir()
-		n := &recNotifier{}
-		ctx, cancel := context.WithCancel(context.Background())
-		done := make(chan struct{})
-		go func() { Watch(ctx, brain, 5*time.Millisecond, n); close(done) }()
-		link := filepath.Join(brain, "late")
-		require.NoError(t, os.Symlink(t.TempDir(), link))
-		waitGone(t, link)
-		cancel()
-		<-done
-		require.Equal(t, 1, n.count(), "iteration %d: the removal alert was lost at shutdown", i)
-	}
-}
-
-// blockingNotifier holds every Notify until its ctx ends, tracking calls in
-// flight.
-type blockingNotifier struct{ inFlight atomic.Int32 }
-
-func (b *blockingNotifier) Notify(ctx context.Context, _ string) error {
-	b.inFlight.Add(1)
-	defer b.inFlight.Add(-1)
-	<-ctx.Done()
-	return ctx.Err()
-}
-
-// Watch does not return while its delivery goroutine is still notifying.
-func TestWatchReturnsOnlyAfterDeliveryHasStopped(t *testing.T) {
-	prev := shutdownFlushTimeout
-	shutdownFlushTimeout = 50 * time.Millisecond
-	t.Cleanup(func() { shutdownFlushTimeout = prev })
-	brain := t.TempDir()
-	n := &blockingNotifier{}
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan struct{})
-	go func() { Watch(ctx, brain, 5*time.Millisecond, n); close(done) }()
-	link := filepath.Join(brain, "x")
-	require.NoError(t, os.Symlink(t.TempDir(), link))
-	waitGone(t, link)
-	require.Eventually(t, func() bool { return n.inFlight.Load() == 1 }, 2*time.Second, time.Millisecond)
-	cancel()
-	select {
-	case <-done:
-	case <-time.After(5 * time.Second):
-		t.Fatal("Watch did not return after cancel")
-	}
-	assert.Zero(t, n.inFlight.Load(), "Notify still running after Watch returned")
-}
-
-// slowToggleNotifier fails slowly (a hung ntfy) while down, then records.
-type slowToggleNotifier struct {
-	recNotifier
-	down    atomic.Bool
-	latency time.Duration
-}
-
-func (r *slowToggleNotifier) Notify(ctx context.Context, m string) error {
-	if r.down.Load() {
-		select {
-		case <-time.After(r.latency):
-		case <-ctx.Done():
-		}
-		return errors.New("ntfy timeout")
-	}
-	return r.recNotifier.Notify(ctx, m)
-}
-
-// Review of PR #180: with a slow notifier the scan's handoff overflows, and
-// those alerts exist only in the overflow counter. Every removal is still
-// delivered or counted in the summary.
-func TestWatchCountsHandoffOverflowWithASlowNotifier(t *testing.T) {
-	brain := t.TempDir()
-	n := &slowToggleNotifier{latency: 30 * time.Millisecond}
-	n.down.Store(true)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	go Watch(ctx, brain, 2*time.Millisecond, n)
-	const plants = 40
-	for i := 0; i < plants; i++ {
-		link := filepath.Join(brain, "ov"+strconv.Itoa(i))
-		require.NoError(t, os.Symlink(t.TempDir(), link))
-		waitGone(t, link)
-	}
-	n.down.Store(false)
-	delivered, counted := 0, 0
-	require.Eventually(t, func() bool {
-		n.mu.Lock()
-		defer n.mu.Unlock()
-		delivered, counted = 0, 0
-		for _, m := range n.msgs {
-			if strings.Contains(m, "removed 1 symlink(s)") {
-				delivered++
-			}
-			if i := strings.Index(m, "): "); i >= 0 && strings.Contains(m, "suppressed") {
-				var c int
-				_, _ = fmt.Sscanf(m[i+3:], "%d", &c)
-				counted += c
-			}
-		}
-		return delivered+counted == plants
-	}, 5*time.Second, 10*time.Millisecond, "delivered %d + counted %d of %d", delivered, counted, plants)
-}
-
-// An alert still queued when Watch stops (its send failed, the notifier has
-// since recovered, the retry tick has not come) is flushed once more before
-// Watch returns, on a ctx that is not the cancelled one: toggleNotifier fails
-// on a done ctx, as the real ntfy notifier does.
-func TestWatchFinalFlushSendsAQueuedAlertOnACtxThatOutlivesTheCancel(t *testing.T) {
-	brain := t.TempDir()
-	n := &toggleNotifier{}
-	n.down.Store(true)
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan struct{})
-	go func() { Watch(ctx, brain, 300*time.Millisecond, n); close(done) }()
-	link := filepath.Join(brain, "queued")
-	require.NoError(t, os.Symlink(t.TempDir(), link))
-	waitGone(t, link)
-	time.Sleep(20 * time.Millisecond) // let the immediate send fail
-	n.down.Store(false)
-	cancel()
-	<-done
-	assert.Equal(t, 1, n.count(), "the queued alert was not flushed at shutdown")
-}
-
-// lockedBuffer is a goroutine-safe log sink: Watch goroutines of earlier
-// tests may still log while one test captures.
-type lockedBuffer struct {
-	mu  sync.Mutex
-	buf bytes.Buffer
-}
-
-func (b *lockedBuffer) Write(p []byte) (int, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return b.buf.Write(p)
-}
-
-func (b *lockedBuffer) String() string { b.mu.Lock(); defer b.mu.Unlock(); return b.buf.String() }
-
-func captureLog(t *testing.T) *lockedBuffer {
-	t.Helper()
-	b := &lockedBuffer{}
-	prev := slog.Default()
-	slog.SetDefault(slog.New(slog.NewTextHandler(b, nil)))
-	t.Cleanup(func() { slog.SetDefault(prev) })
-	return b
-}
-
-// PR #180 round 2: when the final flush fails (ntfy hung at shutdown) the
-// undelivered alerts vanished with only "will retry" warnings. Watch now logs
-// one error with both counts.
-func TestWatchLogsUndeliveredAndSuppressedCountsWhenTheFinalFlushFails(t *testing.T) {
-	prev := shutdownFlushTimeout
-	shutdownFlushTimeout = 50 * time.Millisecond
-	t.Cleanup(func() { shutdownFlushTimeout = prev })
-	logs := captureLog(t)
-	brain := t.TempDir()
-	ctx, cancel := context.WithCancel(context.Background())
-	done := make(chan struct{})
-	go func() { Watch(ctx, brain, 5*time.Millisecond, hungNotifier{latency: time.Hour}); close(done) }()
-	link := filepath.Join(brain, "lost")
-	require.NoError(t, os.Symlink(t.TempDir(), link))
-	waitGone(t, link)
-	cancel()
-	<-done
-	out := logs.String()
-	assert.Contains(t, out, "level=ERROR")
-	assert.Contains(t, out, `msg="symlink tripwire alerts not delivered at shutdown"`)
-	assert.Contains(t, out, "undelivered=1")
-	assert.Contains(t, out, "suppressed=0")
-}
-
-// deliver, given a handoff that already holds alerts and is closed, moves them
-// into the queue and runs the final flush, even though the ctx is cancelled:
-// the drain-on-close path, without depending on when the close lands.
-func TestDeliverFlushesAlertsDrainedFromAClosedHandoffOnACancelledCtx(t *testing.T) {
-	alerts := make(chan string, 3)
-	alerts <- "a1"
-	alerts <- "a2"
-	close(alerts)
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	n := &toggleNotifier{}
-	var overflow atomic.Int64
-	deliver(ctx, time.Hour, n, alerts, &overflow)
-	assert.Equal(t, []string{"a1", "a2"}, n.msgs)
-}
-
-// PR #180 round 2: when the first receive after close finds the handoff empty,
-// overflow counted by the scan was never moved into the summary.
-func TestDeliverCountsOverflowWhenTheHandoffIsClosedAndEmpty(t *testing.T) {
-	alerts := make(chan string)
-	close(alerts)
-	n := &recNotifier{}
-	var overflow atomic.Int64
-	overflow.Store(3)
-	deliver(context.Background(), time.Hour, n, alerts, &overflow)
-	require.Len(t, n.msgs, 1)
-	assert.Contains(t, n.msgs[0], "3 further alert(s)")
-}

ingestion/internal/vectorstore/sync.go

@@ -2,15 +2,12 @@ package vectorstore
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"io/fs"
 	"log/slog"
-	"path"
+	"os"
+	"path/filepath"
 	"strings"
 	"time"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 )
 
 // Embedder produces dense vectors. The embed package's Client satisfies
@@ -93,38 +90,31 @@ func Sync(ctx context.Context, brainDir string, store Store, embedder Embedder)
 	}
 	seenParents := make(map[string]struct{})
 
-	// Through the brain root, regular files only (hyperguild#157): the brain
-	// is a Syncthing folder, and os.ReadFile followed a synced symlink into
-	// the embeddings and blocked on a FIFO.
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return res, fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
-
 	for _, sub := range scanDirs {
-		if _, err := bfs.Lstat(sub); errors.Is(err, fs.ErrNotExist) {
+		root := filepath.Join(brainDir, sub)
+		if _, err := os.Stat(root); os.IsNotExist(err) {
 			continue
 		}
-		// Any other walk error, including a scan root that is a symlink,
-		// aborts the run below.
-		var walkErr error
-		onErr := func(rel string, err error) {
-			if walkErr == nil {
-				walkErr = fmt.Errorf("%s: %w", rel, err)
+
+		err = filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
+			if err != nil {
+				return err
 			}
-		}
-		err = bfs.WalkRegular(sub, func(relSlash string) error {
-			if !strings.HasSuffix(relSlash, ".md") || path.Base(relSlash) == "_index.md" {
+			if d.IsDir() || !strings.HasSuffix(path, ".md") || d.Name() == "_index.md" {
 				return nil
 			}
+			rel, err := filepath.Rel(brainDir, path)
+			if err != nil {
+				return err
+			}
+			relSlash := filepath.ToSlash(rel)
 			seenParents[relSlash] = struct{}{}
 
 			if ps, ok := parents[relSlash]; ok {
 				// File already has chunks in the store. Re-embed only when
 				// the file has been edited since the oldest chunk was
 				// written. Tolerate clock skew with a sub-second grace.
-				info, statErr := bfs.Lstat(relSlash)
+				info, statErr := d.Info()
 				if statErr != nil {
 					res.Errors = append(res.Errors, fmt.Errorf("stat %s: %w", relSlash, statErr))
 					return nil
@@ -142,7 +132,7 @@ func Sync(ctx context.Context, brainDir string, store Store, embedder Embedder)
 				}
 			}
 
-			content, readErr := bfs.ReadRegular(relSlash)
+			content, readErr := os.ReadFile(path)
 			if readErr != nil {
 				res.Errors = append(res.Errors, fmt.Errorf("read %s: %w", relSlash, readErr))
 				return nil
@@ -161,12 +151,7 @@ func Sync(ctx context.Context, brainDir string, store Store, embedder Embedder)
 				res.Added++
 			}
 			return nil
-		}, onErr)
-		if err == nil {
-			err = walkErr
-		}
-		// Abort before the delete pass: an incomplete walk would leave
-		// seenParents short and delete chunks of files that still exist.
+		})
 		if err != nil {
 			return res, fmt.Errorf("walk %s: %w", sub, err)
 		}

ingestion/internal/vectorstore/sync_root_test.go

@@ -1,133 +0,0 @@
-package vectorstore_test
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/vectorstore"
-)
-
-// recordingEmbedder keeps every text it was asked to embed.
-type recordingEmbedder struct {
-	mu    sync.Mutex
-	texts []string
-}
-
-func (e *recordingEmbedder) Embed(_ context.Context, text string) ([]float32, error) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	e.texts = append(e.texts, text)
-	return []float32{1}, nil
-}
-
-func (e *recordingEmbedder) all() string {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	return strings.Join(e.texts, "\n")
-}
-
-// hyperguild#157 slice 3: Sync walked wiki/ and knowledge/ and read each .md
-// with os.ReadFile, so a symlinked note had its target embedded and served by
-// semantic search, and a FIFO stalled the sync.
-func TestSyncRefusesSymlinkedNotesAndSurvivesSwapRaces(t *testing.T) {
-	brain := t.TempDir()
-	writeNote(t, brain, "wiki/w/facts/ok.md", "inside note")
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(brain, "wiki", "w", "facts", "leak.md")))
-	// A link to a file elsewhere in the brain: os.Root allows it, only the
-	// regular-file checks refuse it (hyperguild#171). raw/ is not a scan root,
-	// so its sentinel can only arrive through the link.
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "..", "raw", "s.md"), filepath.Join(brain, "wiki", "w", "facts", "inlink.md")))
-
-	emb := &recordingEmbedder{}
-	store := &stubStore{}
-	_, err := vectorstore.Sync(context.Background(), brain, store, emb)
-	require.NoError(t, err)
-	assert.Contains(t, emb.all(), "inside note", "positive control: the regular note is embedded")
-	assert.NotContains(t, emb.all(), brainfstest.Sentinel)
-	for p := range store.upserts {
-		assert.NotContains(t, p, "leak.md")
-		assert.NotContains(t, p, "inlink.md")
-	}
-
-	p := filepath.Join(brain, "knowledge", "r.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(p), 0o755))
-	sync := func() string {
-		e := &recordingEmbedder{}
-		_, _ = vectorstore.Sync(context.Background(), brain, &stubStore{}, e)
-		return e.all()
-	}
-	brainfstest.AssertNoLeak(t, p, "inside", 1500*time.Millisecond, sync)
-	brainfstest.AssertNoLeakFrom(t, p, "inside", inBrain, 1500*time.Millisecond, sync)
-	brainfstest.AssertNoHang(t, p, "inside", 1500*time.Millisecond, 6*time.Second, func() { _ = sync() })
-}
-
-// Chunks embedded from a symlinked note before this fix are deleted: the
-// note is no longer seen, so the delete pass drops its rows.
-func TestSyncDeletesChunksOfASymlinkedNote(t *testing.T) {
-	brain := t.TempDir()
-	writeNote(t, brain, "wiki/w/facts/ok.md", "inside note")
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(brain, "wiki", "w", "facts", "leak.md")))
-	store := &stubStore{known: map[string]time.Time{
-		"wiki/w/facts/leak.md#0001": {},
-		"wiki/w/facts/ok.md#0001":   {},
-	}}
-	_, err := vectorstore.Sync(context.Background(), brain, store, &recordingEmbedder{})
-	require.NoError(t, err)
-	assert.Equal(t, []string{"wiki/w/facts/leak.md#0001"}, store.deletes)
-}
-
-// A walk error aborts Sync before the delete pass, so chunks of files the
-// walk could not see are kept.
-func TestSyncAbortsBeforeDeletingWhenASubdirIsUnreadable(t *testing.T) {
-	if os.Geteuid() == 0 {
-		t.Skip("root ignores directory permissions")
-	}
-	brain := t.TempDir()
-	writeNote(t, brain, "wiki/w/facts/ok.md", "inside note")
-	locked := filepath.Join(brain, "wiki", "w")
-	require.NoError(t, os.Chmod(locked, 0o000))
-	t.Cleanup(func() { _ = os.Chmod(locked, 0o755) })
-	store := &stubStore{known: map[string]time.Time{"wiki/w/facts/ok.md#0001": {}}}
-	_, err := vectorstore.Sync(context.Background(), brain, store, &recordingEmbedder{})
-	assert.Error(t, err)
-	assert.Empty(t, store.deletes)
-}
-
-// A scan root that is a symlink inside the brain (knowledge -> .) was
-// followed by fs.WalkDir, aliasing raw/, sessions/ and root files into the
-// index. Sync now aborts on it, before embedding or deleting anything.
-func TestSyncAbortsOnASymlinkedScanRoot(t *testing.T) {
-	brain := t.TempDir()
-	writeNote(t, brain, "wiki/w/a.md", "wiki note")
-	writeNote(t, brain, "sessions/s1.md", "session note")
-	require.NoError(t, os.Symlink(".", filepath.Join(brain, "knowledge")))
-	emb := &recordingEmbedder{}
-	store := &stubStore{known: map[string]time.Time{"wiki/w/a.md#0001": {}}}
-	_, err := vectorstore.Sync(context.Background(), brain, store, emb)
-	assert.Error(t, err)
-	assert.NotContains(t, emb.all(), "session note")
-	for p := range store.upserts {
-		assert.False(t, strings.HasPrefix(p, "knowledge/"), "upserted %s", p)
-	}
-	assert.Empty(t, store.deletes)
-}
-
-// A missing scan root is skipped; the other root still syncs.
-func TestSyncSkipsAMissingScanRoot(t *testing.T) {
-	brain := t.TempDir()
-	writeNote(t, brain, "wiki/w/a.md", "wiki note")
-	emb := &recordingEmbedder{}
-	_, err := vectorstore.Sync(context.Background(), brain, &stubStore{}, emb)
-	require.NoError(t, err)
-	assert.Contains(t, emb.all(), "wiki note")
-}

ingestion/internal/watcher/watcher.go

@@ -48,25 +48,8 @@ func Start(ctx context.Context, cfg Config) {
 func processDir(ctx context.Context, cfg Config, date string) []error {
 	rawDir := filepath.Join(cfg.BrainDir, "raw")
 
-	// Every read goes through an os.Root on raw/ (hyperguild#153): raw/ is
-	// writable via Syncthing, and a file swapped for a symlink between the walk
-	// and the read must not lead out of it. A symlinked raw/ is refused.
-	if fi, lerr := os.Lstat(rawDir); lerr != nil {
-		if os.IsNotExist(lerr) {
-			return nil
-		}
-		return []error{fmt.Errorf("stat raw dir: %w", lerr)}
-	} else if fi.Mode()&os.ModeSymlink != 0 || !fi.IsDir() {
-		return []error{fmt.Errorf("raw dir %s is not a real directory; refusing to ingest from it", rawDir)}
-	}
-	root, err := os.OpenRoot(rawDir)
-	if err != nil {
-		return []error{fmt.Errorf("open raw root: %w", err)}
-	}
-	defer func() { _ = root.Close() }()
-
 	var errs []error
-	err = filepath.WalkDir(rawDir, func(path string, d os.DirEntry, err error) error {
+	err := filepath.WalkDir(rawDir, func(path string, d os.DirEntry, err error) error {
 		if err != nil {
 			return err
 		}
@@ -103,10 +86,6 @@ func processDir(ctx context.Context, cfg Config, date string) []error {
 		if strings.HasPrefix(d.Name(), "tunnel-candidates-") {
 			return nil
 		}
-		// Only regular files are notes; a symlink's target may be anywhere.
-		if !d.Type().IsRegular() {
-			return nil
-		}
 
 		// Skip files that have already been processed or permanently failed.
 		if _, err := os.Stat(path + ".processed"); err == nil {
@@ -116,7 +95,7 @@ func processDir(ctx context.Context, cfg Config, date string) []error {
 			return nil
 		}
 
-		if err := processFile(ctx, cfg, root, rawDir, path, date); err != nil {
+		if err := processFile(ctx, cfg, path, date); err != nil {
 			errs = append(errs, fmt.Errorf("process %s: %w", filepath.Base(path), err))
 		}
 		return nil
@@ -130,15 +109,11 @@ func processDir(ctx context.Context, cfg Config, date string) []error {
 // processFile reads a file, calls pipeline.Run, copies it to processed/ or failed/,
 // and writes a marker file next to the original so the watcher skips it next poll.
 // The original file is never deleted, keeping Syncthing-connected vaults (e.g. Obsidian) intact.
-func processFile(ctx context.Context, cfg Config, root *os.Root, rawDir, path, date string) error {
+func processFile(ctx context.Context, cfg Config, path, date string) error {
 	filename := filepath.Base(path)
 	source := deriveSource(filename)
-	rel, err := filepath.Rel(rawDir, path)
-	if err != nil {
-		return fmt.Errorf("relative path: %w", err)
-	}
 
-	content, err := extract.TextIn(root, rel)
+	content, err := extract.Text(path)
 	if err != nil {
 		return fmt.Errorf("extract text: %w", err)
 	}
@@ -151,7 +126,7 @@ func processFile(ctx context.Context, cfg Config, root *os.Root, rawDir, path, d
 			return fmt.Errorf("mkdir failed dir: %w", mkErr)
 		}
 		dest := filepath.Join(failedDir, filename)
-		if cpErr := copyFromRoot(root, rel, dest); cpErr != nil {
+		if cpErr := copyFile(path, dest); cpErr != nil {
 			return fmt.Errorf("copy to failed: %w", cpErr)
 		}
 		if mkErr := os.WriteFile(path+".failed", []byte(runErr.Error()), 0o644); mkErr != nil {
@@ -179,7 +154,7 @@ func processFile(ctx context.Context, cfg Config, root *os.Root, rawDir, path, d
 		base := strings.TrimSuffix(filename, ext)
 		dest = filepath.Join(processedDir, base+"-"+time.Now().UTC().Format("150405")+ext)
 	}
-	if err := copyFromRoot(root, rel, dest); err != nil {
+	if err := copyFile(path, dest); err != nil {
 		return fmt.Errorf("copy to processed: %w", err)
 	}
 	if err := os.WriteFile(path+".processed", []byte(date), 0o644); err != nil {
@@ -190,6 +165,26 @@ func processFile(ctx context.Context, cfg Config, root *os.Root, rawDir, path, d
 	return nil
 }
 
+// copyFile copies src to dst, creating dst if it doesn't exist.
+func copyFile(src, dst string) error {
+	in, err := os.Open(src)
+	if err != nil {
+		return fmt.Errorf("open src: %w", err)
+	}
+	defer in.Close() //nolint:errcheck
+
+	out, err := os.Create(dst)
+	if err != nil {
+		return fmt.Errorf("create dst: %w", err)
+	}
+
+	if _, err := io.Copy(out, in); err != nil {
+		out.Close() //nolint:errcheck
+		return fmt.Errorf("copy: %w", err)
+	}
+	return out.Close()
+}
+
 // deriveSource turns a filename into a human-readable source name.
 // "shape-up-book.md" → "Shape Up Book"
 func deriveSource(filename string) string {
@@ -226,30 +221,3 @@ func appendWatcherLog(brainDir, filename string, runErr error, date string) erro
 	}
 	return f.Close()
 }
-
-// copyFromRoot archives a raw/ file read through the root, refusing anything
-// that is not a regular file, so a swapped-in symlink cannot copy an outside
-// file into raw/processed/ or raw/failed/ (hyperguild#153).
-func copyFromRoot(root *os.Root, rel, dst string) error {
-	fi, err := root.Lstat(rel)
-	if err != nil {
-		return err
-	}
-	if !fi.Mode().IsRegular() {
-		return fmt.Errorf("%s: not a regular file", rel)
-	}
-	in, _, err := extract.OpenRegular(root, rel)
-	if err != nil {
-		return err
-	}
-	defer func() { _ = in.Close() }()
-	out, err := os.Create(dst)
-	if err != nil {
-		return err
-	}
-	if _, err := io.Copy(out, in); err != nil {
-		_ = out.Close()
-		return err
-	}
-	return out.Close()
-}

ingestion/internal/watcher/watcher_test.go

@@ -7,10 +7,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"syscall"
 	"testing"
 	"time"
 
@@ -286,107 +282,3 @@ func TestProcessDir_SkipsTunnelCandidateFiles(t *testing.T) {
 	_, err = os.Stat(filepath.Join(brainDir, "raw", "processed", date, "tunnel-candidates-2026-07-19.md"))
 	assert.True(t, os.IsNotExist(err), "tunnel-candidates file should not be copied to processed/")
 }
-
-// hyperguild#153: raw/ is writable via Syncthing, and the watcher ingests
-// whatever lands there with no API call at all. WalkDir yields symlinked
-// files, and extract.Text followed them, so a symlink to any pod-readable
-// file would be extracted into the brain. The watcher now ingests only
-// regular files, read through an os.Root on raw/.
-func TestProcessDir_IngestsTheRealNoteAndSkipsTheSymlinkBesideIt(t *testing.T) {
-	brainDir := setupBrainDir(t)
-	outside := filepath.Join(t.TempDir(), "secret.md")
-	require.NoError(t, os.WriteFile(outside, []byte("SENTINEL-153-WATCHER"), 0o644))
-	// "a-" sorts before "real": a walk that stopped at the first symlink
-	// (filepath.SkipAll — one synced link halting all ingestion) would fail
-	// the call count below (PR #156 review).
-	require.NoError(t, os.Symlink(outside, filepath.Join(brainDir, "raw", "a-leak.md")))
-	require.NoError(t, os.WriteFile(filepath.Join(brainDir, "raw", "real.md"), []byte("real note"), 0o644))
-
-	var sawSentinel bool
-	calls := 0
-	cfg := Config{BrainDir: brainDir, Interval: time.Hour, Pipeline: pipeline.Config{
-		Complete: func(_ context.Context, _, user string) (string, error) {
-			calls++
-			if strings.Contains(user, "SENTINEL-153-WATCHER") {
-				sawSentinel = true
-			}
-			b, _ := json.Marshal([]pipeline.RawPage{{Title: "X", Type: "source", Subtype: "article", Content: "## S\n\nx\n"}})
-			return string(b), nil
-		},
-		Schema: "# Schema",
-	}}
-	errs := processDir(context.Background(), cfg, time.Now().UTC().Format("2006-01-02"))
-	assert.Empty(t, errs)
-	assert.False(t, sawSentinel, "the symlink target must never reach the pipeline")
-	assert.Equal(t, 1, calls, "exactly the real note is ingested; the symlink is not a note")
-}
-
-// A symlinked raw/ is refused outright: os.OpenRoot would otherwise follow
-// it and confine reads to wherever it points.
-func TestProcessDir_RefusesASymlinkedRawDir(t *testing.T) {
-	brainDir := t.TempDir()
-	elsewhere := t.TempDir()
-	require.NoError(t, os.WriteFile(filepath.Join(elsewhere, "x.md"), []byte("SENTINEL-153-RAWLINK"), 0o644))
-	require.NoError(t, os.Symlink(elsewhere, filepath.Join(brainDir, "raw")))
-	calls := 0
-	cfg := Config{BrainDir: brainDir, Interval: time.Hour, Pipeline: pipeline.Config{
-		Complete: func(context.Context, string, string) (string, error) { calls++; return "[]", nil },
-		Schema:   "# Schema",
-	}}
-	errs := processDir(context.Background(), cfg, time.Now().UTC().Format("2006-01-02"))
-	assert.NotEmpty(t, errs, "a symlinked raw/ must be reported, not silently ingested")
-	assert.Zero(t, calls)
-}
-
-// PR #156: a FIFO swapped into raw/ between the watcher's checks and its
-// read or archive copy must not hang the watcher, which runs unattended.
-func TestProcessDir_DoesNotHangUnderAFIFOSwapRace(t *testing.T) {
-	brainDir := setupBrainDir(t)
-	raw := filepath.Join(brainDir, "raw")
-	var stop atomic.Bool
-	var wg sync.WaitGroup
-	wg.Add(1)
-	// Awaited before t.TempDir's cleanup (hyperguild#162).
-	t.Cleanup(func() { stop.Store(true); wg.Wait() })
-	go func() {
-		defer wg.Done()
-		for i := 0; !stop.Load(); i++ {
-			tmp := filepath.Join(raw, ".swap")
-			_ = os.Remove(tmp)
-			if i%2 == 0 {
-				_ = os.WriteFile(tmp, []byte("x"), 0o644)
-			} else {
-				_ = syscall.Mkfifo(tmp, 0o644)
-			}
-			_ = os.Rename(tmp, filepath.Join(raw, "r.md"))
-		}
-	}()
-	cfg := Config{BrainDir: brainDir, Interval: time.Hour, Pipeline: pipeline.Config{
-		Complete: func(context.Context, string, string) (string, error) {
-			b, _ := json.Marshal([]pipeline.RawPage{{Title: "R", Type: "source", Subtype: "article", Content: "## S\n\nx\n"}})
-			return string(b), nil
-		},
-		Schema: "# Schema",
-	}}
-	var iters atomic.Int64
-	done := make(chan struct{})
-	go func() {
-		for deadline := time.Now().Add(1500 * time.Millisecond); time.Now().Before(deadline); {
-			_ = os.Remove(filepath.Join(raw, "r.md.processed"))
-			_ = os.Remove(filepath.Join(raw, "r.md.failed"))
-			_ = processDir(context.Background(), cfg, "2026-10-03")
-			iters.Add(1)
-		}
-		close(done)
-	}()
-	select {
-	case <-done:
-		stop.Store(true)
-	case <-time.After(8 * time.Second):
-		stop.Store(true)
-		if f, err := os.OpenFile(filepath.Join(raw, "r.md"), os.O_WRONLY|syscall.O_NONBLOCK, 0); err == nil {
-			_ = f.Close()
-		}
-		t.Fatalf("the watcher hung on a swapped-in FIFO after %d iterations", iters.Load())
-	}
-}

ingestion/internal/wiki/index.go

@@ -3,9 +3,10 @@ package wiki
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
 	"strings"
 
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 	"github.com/mathiasbq/hyperguild/ingestion/internal/textutil"
 )
 
@@ -15,11 +16,6 @@ func RebuildIndex(brainDir, date string) error {
 	if err != nil {
 		return fmt.Errorf("load inventory: %w", err)
 	}
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
 
 	total := len(inv[PageTypeConcept]) + len(inv[PageTypeEntity]) + len(inv[PageTypeSource])
 	var sb strings.Builder
@@ -38,7 +34,7 @@ func RebuildIndex(brainDir, date string) error {
 		label := strings.ToUpper(string(pt)[:1]) + string(pt)[1:]
 		fmt.Fprintf(&sb, "## %s\n\n", label)
 		for _, e := range entries {
-			summary := pageFirstSentence(bfs, e)
+			summary := pageFirstSentence(brainDir, e)
 			if summary != "" {
 				fmt.Fprintf(&sb, "- [[%s|%s]] — %s\n", e.Slug, e.Title, summary)
 			} else {
@@ -48,14 +44,13 @@ func RebuildIndex(brainDir, date string) error {
 		sb.WriteString("\n")
 	}
 
-	// Written through the brain root, never through a symlink (#158).
-	return bfs.PutRegular("wiki/index.md", []byte(sb.String()))
+	dest := filepath.Join(brainDir, "wiki", "index.md")
+	return os.WriteFile(dest, []byte(sb.String()), 0o644)
 }
 
-// pageFirstSentence reads the page through the brain root, regular files
-// only (hyperguild#157).
-func pageFirstSentence(bfs *brainfs.Brain, e Entry) string {
-	content, err := bfs.ReadRegular("wiki/" + string(e.Type) + "/" + e.Slug + ".md")
+func pageFirstSentence(brainDir string, e Entry) string {
+	path := filepath.Join(brainDir, "wiki", string(e.Type), e.Slug+".md")
+	content, err := os.ReadFile(path)
 	if err != nil {
 		return ""
 	}

ingestion/internal/wiki/inventory.go

@@ -3,45 +3,36 @@ package wiki
 
 import (
 	"bufio"
-	"bytes"
-	"errors"
 	"fmt"
-	"io/fs"
+	"os"
+	"path/filepath"
 	"strings"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
 )
 
 // LoadInventory walks brain/wiki/ and returns all pages grouped by type.
-// Missing subdirectories are silently skipped. Pages are listed and read
-// through the brain root, regular files only (hyperguild#157); a type
-// directory that is a symlink is an error.
+// Missing subdirectories are silently skipped.
 func LoadInventory(brainDir string) (map[PageType][]Entry, error) {
 	result := map[PageType][]Entry{
 		PageTypeConcept: {},
 		PageTypeEntity:  {},
 		PageTypeSource:  {},
 	}
-	bfs, err := brainfs.Open(brainDir)
-	if err != nil {
-		return nil, fmt.Errorf("open brain: %w", err)
-	}
-	defer func() { _ = bfs.Close() }()
 	for pt := range result {
-		dir := "wiki/" + string(pt)
-		names, err := bfs.ReadDirRegular(dir)
-		if errors.Is(err, fs.ErrNotExist) {
+		dir := filepath.Join(brainDir, "wiki", string(pt))
+		entries, err := os.ReadDir(dir)
+		if os.IsNotExist(err) {
 			continue
 		}
 		if err != nil {
 			return nil, fmt.Errorf("read dir %s: %w", dir, err)
 		}
-		for _, name := range names {
-			if !strings.HasSuffix(name, ".md") {
+		for _, e := range entries {
+			if e.IsDir() || !strings.HasSuffix(e.Name(), ".md") {
 				continue
 			}
-			slug := strings.TrimSuffix(name, ".md")
-			title, aliases := readFrontmatter(bfs, dir+"/"+name, slug)
+			slug := strings.TrimSuffix(e.Name(), ".md")
+			path := filepath.Join(dir, e.Name())
+			title, aliases := readFrontmatter(path, slug)
 			result[pt] = append(result[pt], Entry{Slug: slug, Title: title, Aliases: aliases, Type: pt})
 		}
 	}
@@ -50,14 +41,15 @@ func LoadInventory(brainDir string) (map[PageType][]Entry, error) {
 
 // readFrontmatter extracts title and aliases from YAML frontmatter.
 // Falls back to slug for title and empty aliases on any error.
-func readFrontmatter(bfs *brainfs.Brain, rel, fallbackSlug string) (title string, aliases []string) {
+func readFrontmatter(path, fallbackSlug string) (title string, aliases []string) {
 	title = fallbackSlug
-	content, err := bfs.ReadRegular(rel)
+	f, err := os.Open(path)
 	if err != nil {
 		return
 	}
+	defer f.Close() //nolint:errcheck
 
-	scanner := bufio.NewScanner(bytes.NewReader(content))
+	scanner := bufio.NewScanner(f)
 	inFM := false
 	inAliases := false
 	for scanner.Scan() {

ingestion/internal/wiki/log.go

@@ -3,7 +3,8 @@ package wiki
 
 import (
 	"fmt"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
+	"os"
+	"path/filepath"
 	"strings"
 )
 
@@ -26,14 +27,14 @@ func AppendLog(brainDir, source string, pages, warnings []string, date string) e
 	}
 	sb.WriteString("\n")
 
-	// Appended through the brain root, never through a symlink (#158).
-	bfs, err := brainfs.Open(brainDir)
+	logPath := filepath.Join(brainDir, "log.md")
+	f, err := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
 	if err != nil {
-		return fmt.Errorf("open brain: %w", err)
+		return fmt.Errorf("open log: %w", err)
 	}
-	defer func() { _ = bfs.Close() }()
-	if err := bfs.AppendRegular("log.md", []byte(sb.String())); err != nil {
+	if _, err = f.WriteString(sb.String()); err != nil {
+		f.Close() //nolint:errcheck
 		return fmt.Errorf("write log: %w", err)
 	}
-	return nil
+	return f.Close()
 }

ingestion/internal/wiki/root_test.go

@@ -1,79 +0,0 @@
-package wiki
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs"
-	"github.com/mathiasbq/hyperguild/ingestion/internal/brainfs/brainfstest"
-)
-
-// hyperguild#157 slice 4: LoadInventory listed wiki/<type>/ with os.ReadDir
-// and opened each .md by path, so a symlinked page put the target's title and
-// aliases into the inventory (and the LLM prompts built from it), and a FIFO
-// hung it. RebuildIndex read first sentences the same way.
-func TestLoadInventoryRefusesSymlinksAndSurvivesSwapRaces(t *testing.T) {
-	brain := t.TempDir()
-	dir := filepath.Join(brain, "wiki", "concepts")
-	require.NoError(t, os.MkdirAll(dir, 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(dir, "ok.md"), []byte("---\ntitle: zqinside\n---\n"), 0o644))
-	require.NoError(t, os.Symlink(brainfstest.Outside(t), filepath.Join(dir, "leak.md")))
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	require.NoError(t, os.Symlink(filepath.Join("..", "..", "raw", "s.md"), filepath.Join(dir, "inlink.md")))
-
-	inv, err := LoadInventory(brain)
-	require.NoError(t, err)
-	got := fmt.Sprintf("%+v", inv)
-	assert.Contains(t, got, "zqinside", "positive control")
-	assert.NotContains(t, got, brainfstest.Sentinel)
-	assert.NotContains(t, got, "leak", "a symlinked page is not listed")
-	assert.NotContains(t, got, "inlink", "a page linked to another brain file is not listed")
-
-	p := filepath.Join(dir, "r.md")
-	read := func() string {
-		inv, _ := LoadInventory(brain)
-		return fmt.Sprintf("%+v", inv)
-	}
-	brainfstest.AssertNoLeak(t, p, "---\ntitle: zqinside\n---\n", 1500*time.Millisecond, read)
-	brainfstest.AssertNoLeakFrom(t, p, "---\ntitle: zqinside\n---\n", inBrain, 1500*time.Millisecond, read)
-	brainfstest.AssertNoHang(t, p, "---\ntitle: zqinside\n---\n", 1500*time.Millisecond, 6*time.Second, func() { _ = read() })
-}
-
-func TestLoadInventoryReturnsErrNotRegularForASymlinkedTypeDir(t *testing.T) {
-	brain := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "wiki"), 0o755))
-	require.NoError(t, os.MkdirAll(filepath.Join(brain, "raw"), 0o755))
-	require.NoError(t, os.WriteFile(filepath.Join(brain, "raw", "r.md"), []byte("---\ntitle: zqrawonly\n---\n"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw"), filepath.Join(brain, "wiki", "concepts")))
-	inv, err := LoadInventory(brain)
-	require.ErrorIs(t, err, brainfs.ErrNotRegular)
-	assert.NotContains(t, fmt.Sprintf("%+v", inv), "zqrawonly")
-}
-
-func TestRebuildIndexDoesNotReadAPageSwappedForASymlink(t *testing.T) {
-	brain := t.TempDir()
-	dir := filepath.Join(brain, "wiki", "concepts")
-	require.NoError(t, os.MkdirAll(dir, 0o755))
-	p := filepath.Join(dir, "r.md")
-	require.NoError(t, os.WriteFile(p, []byte("---\ntitle: R\n---\nzqinside sentence.\n"), 0o644))
-	require.NoError(t, RebuildIndex(brain, "2026-10-04"))
-	idx, err := os.ReadFile(filepath.Join(brain, "wiki", "index.md"))
-	require.NoError(t, err)
-	require.Contains(t, string(idx), "zqinside", "positive control: the summary is read")
-
-	read := func() string {
-		_ = RebuildIndex(brain, "2026-10-04")
-		b, _ := os.ReadFile(filepath.Join(brain, "wiki", "index.md"))
-		return string(b)
-	}
-	brainfstest.AssertNoLeak(t, p, "---\ntitle: R\n---\nzqinside sentence.\n", 1500*time.Millisecond, read)
-	inBrain := brainfstest.WriteSentinelAt(t, filepath.Join(brain, "raw", "s.md"))
-	brainfstest.AssertNoLeakFrom(t, p, "---\ntitle: R\n---\nzqinside sentence.\n", inBrain, 1500*time.Millisecond, read)
-	brainfstest.AssertNoHang(t, p, "---\ntitle: R\n---\nzqinside sentence.\n", 1500*time.Millisecond, 6*time.Second, func() { _ = read() })
-}

ingestion/internal/wiki/writers_redirect_test.go

@@ -1,35 +0,0 @@
-package wiki
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// hyperguild#158: RebuildIndex wrote wiki/index.md and AppendLog appended
-// log.md with os.WriteFile / os.OpenFile, so a symlinked file was written
-// through.
-func TestRebuildIndexAndAppendLogDoNotWriteThroughSymlinks(t *testing.T) {
-	b := t.TempDir()
-	require.NoError(t, os.MkdirAll(filepath.Join(b, "wiki", "concepts"), 0o755))
-	victim := filepath.Join(b, "raw", "v.md")
-	require.NoError(t, os.MkdirAll(filepath.Dir(victim), 0o755))
-	require.NoError(t, os.WriteFile(victim, []byte("untouched"), 0o644))
-	require.NoError(t, os.Symlink(filepath.Join("..", "raw", "v.md"), filepath.Join(b, "wiki", "index.md")))
-	require.NoError(t, os.Symlink(filepath.Join("raw", "v.md"), filepath.Join(b, "log.md")))
-
-	assert.Error(t, RebuildIndex(b, "2026-10-05"))
-	assert.Error(t, AppendLog(b, "src", []string{"p"}, nil, "2026-10-05"))
-	got, _ := os.ReadFile(victim)
-	assert.Equal(t, "untouched", string(got))
-
-	require.NoError(t, os.Remove(filepath.Join(b, "wiki", "index.md")))
-	require.NoError(t, os.Remove(filepath.Join(b, "log.md")))
-	require.NoError(t, RebuildIndex(b, "2026-10-05"), "positive control")
-	require.NoError(t, AppendLog(b, "src", []string{"p"}, nil, "2026-10-05"), "positive control")
-	l, _ := os.ReadFile(filepath.Join(b, "log.md"))
-	assert.Contains(t, string(l), "src")
-}