hyperguild/docs/superpowers/plans/2026-04-22-brain-ingestion-pipeline.md

# Brain Ingestion Pipeline Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Add a structured LLM-powered ingestion pipeline to the hyperguild brain: two new HTTP endpoints (`/ingest`, `/ingest-path`) and a background file watcher on `brain/raw/`, producing concepts/entities/sources wiki pages.

**Architecture:** Raw content (passed directly or read from files) is chunked, sent to an OpenAI-compatible LLM with the brain schema and existing wiki inventory as context, and the returned JSON array of `{path, content}` objects is merged and written to `brain/wiki/`. A background goroutine polls `brain/raw/` and processes dropped files automatically. The supervisor's `brain_ingest` skill connects to the ingestion server's `/ingest` endpoint.

**Tech Stack:** Go stdlib, `testify` (already in go.mod), OpenAI-compatible chat completions API via LiteLLM.

---

## File Map

### New files — `ingestion` module

| File | Responsibility |
|---|---|
| `ingestion/internal/wiki/types.go` | `Page` struct, `PageType` constants |
| `ingestion/internal/wiki/slug.go` | `Slug(title) string` |
| `ingestion/internal/wiki/slug_test.go` | Slug edge case tests |
| `ingestion/internal/wiki/merge.go` | `Merge(a, b Page) Page`, section parsing |
| `ingestion/internal/wiki/merge_test.go` | Merge strategy tests |
| `ingestion/internal/wiki/inventory.go` | `LoadInventory(brainDir) (map[PageType][]Entry, error)` |
| `ingestion/internal/wiki/inventory_test.go` | Inventory loading tests |
| `ingestion/internal/wiki/index.go` | `RebuildIndex(brainDir, date string) error` |
| `ingestion/internal/wiki/log.go` | `AppendLog(brainDir, source string, pages, warnings []string, date string) error` |
| `ingestion/internal/wiki/index_test.go` | Index + log tests |
| `ingestion/internal/llm/client.go` | `Client`, `Complete(ctx, system, user string) (string, error)` |
| `ingestion/internal/llm/client_test.go` | Mock server tests |
| `ingestion/internal/pipeline/chunk.go` | `Chunk(content string, maxSize int) []string` |
| `ingestion/internal/pipeline/chunk_test.go` | Chunking tests |
| `ingestion/internal/pipeline/parse.go` | `ParsePages(output string) ([]wiki.Page, []string)` |
| `ingestion/internal/pipeline/parse_test.go` | Parse + truncation recovery tests |
| `ingestion/internal/pipeline/prompt.go` | `BuildPrompt(...)` |
| `ingestion/internal/pipeline/pipeline.go` | `Config`, `Run(...)` |
| `ingestion/internal/pipeline/pipeline_test.go` | Integration test with mock LLM |
| `ingestion/internal/watcher/watcher.go` | `Config`, `Watcher`, `Start`, `processFile` |
| `ingestion/internal/watcher/watcher_test.go` | File move behaviour tests |
| `brain/CLAUDE.md` | Schema injected into every ingest prompt |

### Modified files

| File | Change |
|---|---|
| `ingestion/internal/api/handler.go` | Add `Ingest`, `IngestPath` methods; update `NewHandler` signature |
| `ingestion/internal/api/handler_test.go` | Update `NewHandler` call; add ingest handler tests |
| `ingestion/cmd/server/main.go` | New env vars, wire pipeline config, start watcher |
| `internal/config/config.go` | Add `IngestSvcURL`, `KBRetrievalURL` fields |
| `cmd/supervisor/main.go` | Pass new fields to `brain.New()` |

---

## Task 1: Supervisor config wiring

Wire `IngestSvcURL` and `KBRetrievalURL` into the supervisor so `brain_ingest` and `brain_search` become active when configured.

**Files:**
- Modify: `internal/config/config.go`
- Modify: `cmd/supervisor/main.go:106-108`

- [ ] **Step 1: Add fields to Config**

In `internal/config/config.go`, add two fields and their env-var loading:

```go
type Config struct {
	Port           string
	LiteLLMBaseURL string
	LiteLLMAPIKey  string
	ConfigDir      string
	ModelsFile     string
	IngestBaseURL  string
	IngestSvcURL   string // INGEST_SVC_URL — brain_ingest endpoint
	KBRetrievalURL string // KB_RETRIEVAL_URL — brain_search endpoint
	SessionsDir    string
	BrainDir       string
}

func Load() (Config, error) {
	cfg := Config{
		Port:           envOr("SUPERVISOR_PORT", "3200"),
		LiteLLMBaseURL: envOr("LITELLM_BASE_URL", "http://iguana:4000"),
		LiteLLMAPIKey:  os.Getenv("LITELLM_API_KEY"),
		ConfigDir:      envOr("SUPERVISOR_CONFIG_DIR", "./config/supervisor"),
	}
	cfg.ModelsFile = envOr("SUPERVISOR_MODELS_FILE", cfg.ConfigDir+"/../models.yaml")
	cfg.IngestBaseURL = envOr("INGEST_BASE_URL", "http://localhost:3300")
	cfg.IngestSvcURL = os.Getenv("INGEST_SVC_URL")
	cfg.KBRetrievalURL = os.Getenv("KB_RETRIEVAL_URL")
	cfg.SessionsDir = envOr("SUPERVISOR_SESSIONS_DIR", "./brain/sessions")
	cfg.BrainDir = envOr("SUPERVISOR_BRAIN_DIR", "./brain")
	return cfg, nil
}
```

- [ ] **Step 2: Pass to brain.New() in main.go**

Find the `brain.New(...)` call in `cmd/supervisor/main.go` (around line 106) and update it:

```go
reg.Register(brain.New(brain.Config{
    IngestBaseURL:  cfg.IngestBaseURL,
    IngestSvcURL:   cfg.IngestSvcURL,
    KBRetrievalURL: cfg.KBRetrievalURL,
}))
```

- [ ] **Step 3: Build and verify**

```bash
cd /Users/mathias/dev/AI/hyperguild && go build ./...
```

Expected: no output (clean build).

- [ ] **Step 4: Commit**

```bash
git add internal/config/config.go cmd/supervisor/main.go
git commit -m "feat(config): add IngestSvcURL and KBRetrievalURL to supervisor config"
```

---

## Task 2: brain/CLAUDE.md schema document

Create the schema document injected into every ingest prompt. This teaches the LLM the wiki structure and rules.

**Files:**
- Create: `brain/CLAUDE.md`

- [ ] **Step 1: Write the schema**

Create `brain/CLAUDE.md`:

```markdown
# Brain Wiki Schema

This document defines the three page types in the brain wiki.
The LLM must follow this schema exactly when generating wiki pages.

## Wikilink Format

All cross-references use `[[slug|Display Text]]`.

Rules:
- slug = lowercase filename without .md, spaces → hyphens, strip all non-alphanumeric except hyphens
- The `|` separator is REQUIRED — never use `[[Title]]` without a slug
- Examples: `[[domain-driven-design|Domain Driven Design]]`, `[[ryan-singer|Ryan Singer]]`
- Slugs must resolve to an existing file in the inventory, or a file you are creating in this response

Slug generation examples:
- "Domain Driven Design" → `domain-driven-design`
- "It's Complicated" → `its-complicated`
- "gRPC" → `grpc`
- "GPT-4o" → `gpt-4o`

## Domains

Use one of: `ai-llm`, `software-engineering`, `product-strategy`, `finance-markets`,
`personal`, `consulting`, `climate`, `infrastructure`, `security`

---

## Source Pages — wiki/sources/<slug>.md

One page per ingested source. Books are NEVER split across multiple source pages — update the existing one.

Required frontmatter:
```yaml
title: <exact title>
type: article | pdf | book | video | note | project
domain: <domain>
date_ingested: YYYY-MM-DD
last_updated: YYYY-MM-DD
aliases:
  - <exact title>
```

Body sections (in this order):

### Summary
2–3 sentences. Core argument or finding.

### Key Claims
Bulleted list. Paraphrase — no verbatim quotes or code.

### Concepts Introduced or Reinforced
Wikilinks to wiki/concepts/ ONLY. One per line.

### Entities Mentioned
Wikilinks to wiki/entities/ ONLY. One per line.

### Open Questions Raised
Gaps or follow-up questions from this source.

For books only, also add:

### Chapters
One bullet per chapter with 1–2 sentence summary.

### Argument Arc
Overall narrative as it becomes clear across chapters.

### Updates
Dated entries appended on re-ingestion. NEVER rewrite — only append.

---

## Concept Pages — wiki/concepts/<slug>.md

One page per idea, framework, methodology, or pattern.

Required frontmatter:
```yaml
title: <concept name>
domain: <domain>
last_updated: YYYY-MM-DD
aliases:
  - <exact title>
```

Body sections (in this order):

### Definition
One-paragraph plain-language explanation.

### Why It Matters
Practical significance. Why should anyone care?

### Related Concepts
Wikilinks to wiki/concepts/ ONLY.

### Related Entities
Wikilinks to wiki/entities/ ONLY.

### Sources
Wikilinks to wiki/sources/ ONLY.

### Evolving Notes
Updated as new sources arrive. Append, do not rewrite.

---

## Entity Pages — wiki/entities/<slug>.md

One page per person, tool, organisation, technology, or product.

Required frontmatter:
```yaml
title: <name>
type: person | company | tool | model | framework | technology
domain: <domain>
last_updated: YYYY-MM-DD
aliases:
  - <exact title>
```

Body sections (in this order):

### Description
One-line description.

### Relevance
Why this entity matters to this knowledge base.

### Key Positions, Products, or Claims
With dates where known.

### Related Concepts
Wikilinks to wiki/concepts/ ONLY.

### Related Entities
Wikilinks to wiki/entities/ ONLY.

### Sources
Wikilinks to wiki/sources/ ONLY.

---

## Non-Negotiable Rules

1. Output ONLY a valid JSON array — no markdown fences, no prose before or after
2. Each element: `{"path": "wiki/<type>/<slug>.md", "content": "...full markdown..."}`
3. Slugs are kebab-case: lowercase, spaces→hyphens, strip special characters
4. Every wikilink must be `[[slug|Display Text]]` — the pipe separator is required
5. Dates always YYYY-MM-DD
6. Never reproduce verbatim code — describe the pattern or technique
7. Section links must match their section type (Related Concepts → concepts/ only, etc.)
8. One source page per book — if inventory shows it exists, include it as an UPDATE
```

- [ ] **Step 2: Commit**

```bash
git add brain/CLAUDE.md
git commit -m "docs(brain): add wiki schema document for ingest prompt"
```

---

## Task 3: wiki/slug — slug generation

**Files:**
- Create: `ingestion/internal/wiki/types.go`
- Create: `ingestion/internal/wiki/slug.go`
- Create: `ingestion/internal/wiki/slug_test.go`

- [ ] **Step 1: Write types.go**

```go
// ingestion/internal/wiki/types.go
package wiki

// PageType identifies the wiki subdirectory for a page.
type PageType string

const (
	PageTypeConcept PageType = "concepts"
	PageTypeEntity  PageType = "entities"
	PageTypeSource  PageType = "sources"
)

// Page is a wiki page to be written to disk.
type Page struct {
	Path    string // relative to brainDir, e.g. "wiki/sources/foo.md"
	Content string // full markdown including YAML frontmatter
}

// Entry is a summary of an existing wiki page used to build the inventory.
type Entry struct {
	Slug  string
	Title string
	Type  PageType
}
```

- [ ] **Step 2: Write the failing test**

```go
// ingestion/internal/wiki/slug_test.go
package wiki

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestSlug(t *testing.T) {
	tests := []struct {
		input string
		want  string
	}{
		{"Domain Driven Design", "domain-driven-design"},
		{"It's Complicated", "its-complicated"},
		{"gRPC", "grpc"},
		{"GPT-4o", "gpt-4o"},
		{"Property 1: It's Rough", "property-1-its-rough"},
		{"  leading spaces  ", "leading-spaces"},
		{"multiple   spaces", "multiple-spaces"},
		{"already-kebab", "already-kebab"},
	}
	for _, tc := range tests {
		t.Run(tc.input, func(t *testing.T) {
			assert.Equal(t, tc.want, Slug(tc.input))
		})
	}
}
```

- [ ] **Step 3: Run test to verify it fails**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/wiki/... 2>&1
```

Expected: `undefined: Slug`

- [ ] **Step 4: Write slug.go**

```go
// ingestion/internal/wiki/slug.go
package wiki

import (
	"strings"
	"unicode"
)

// Slug converts a title to a kebab-case slug suitable for wiki filenames.
// Rules: lowercase, spaces/hyphens/underscores → hyphens, strip everything else.
func Slug(title string) string {
	var b strings.Builder
	prevHyphen := true // start true to trim leading hyphens
	for _, r := range strings.ToLower(title) {
		switch {
		case r == ' ' || r == '-' || r == '_':
			if !prevHyphen {
				b.WriteRune('-')
				prevHyphen = true
			}
		case unicode.IsLetter(r) || unicode.IsDigit(r):
			b.WriteRune(r)
			prevHyphen = false
		// all other characters (apostrophes, colons, dots, etc.) are dropped
		}
	}
	return strings.TrimRight(b.String(), "-")
}
```

- [ ] **Step 5: Run test to verify it passes**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/wiki/... -run TestSlug -v
```

Expected: all cases PASS.

- [ ] **Step 6: Commit**

```bash
git add ingestion/internal/wiki/
git commit -m "feat(ingestion): add wiki package with Page types and slug generation"
```

---

## Task 4: wiki/merge — page merge logic

**Files:**
- Create: `ingestion/internal/wiki/merge.go`
- Create: `ingestion/internal/wiki/merge_test.go`

- [ ] **Step 1: Write the failing tests**

```go
// ingestion/internal/wiki/merge_test.go
package wiki

import (
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestMerge_BulletSectionsUnion(t *testing.T) {
	a := Page{Path: "wiki/concepts/foo.md", Content: "---\ntitle: Foo\n---\n\n## Related Concepts\n\n- [[bar|Bar]]\n"}
	b := Page{Path: "wiki/concepts/foo.md", Content: "---\ntitle: Foo\n---\n\n## Related Concepts\n\n- [[bar|Bar]]\n- [[baz|Baz]]\n"}

	got := Merge(a, b)
	assert.Contains(t, got.Content, "[[bar|Bar]]")
	assert.Contains(t, got.Content, "[[baz|Baz]]")
	// bar appears only once
	assert.Equal(t, 1, strings.Count(got.Content, "[[bar|Bar]]"))
}

func TestMerge_AppendSections(t *testing.T) {
	a := Page{Path: "wiki/concepts/foo.md", Content: "---\ntitle: Foo\n---\n\n## Evolving Notes\n\nFirst note.\n"}
	b := Page{Path: "wiki/concepts/foo.md", Content: "---\ntitle: Foo\n---\n\n## Evolving Notes\n\nSecond note.\n"}

	got := Merge(a, b)
	assert.Contains(t, got.Content, "First note.")
	assert.Contains(t, got.Content, "Second note.")
}

func TestMerge_KeepFirstForOtherSections(t *testing.T) {
	a := Page{Path: "wiki/concepts/foo.md", Content: "---\ntitle: Foo\n---\n\n## Definition\n\nFirst definition.\n"}
	b := Page{Path: "wiki/concepts/foo.md", Content: "---\ntitle: Foo\n---\n\n## Definition\n\nSecond definition.\n"}

	got := Merge(a, b)
	assert.Contains(t, got.Content, "First definition.")
	assert.NotContains(t, got.Content, "Second definition.")
}

func TestMerge_NewSectionFromB(t *testing.T) {
	a := Page{Path: "wiki/concepts/foo.md", Content: "---\ntitle: Foo\n---\n\n## Definition\n\nA thing.\n"}
	b := Page{Path: "wiki/concepts/foo.md", Content: "---\ntitle: Foo\n---\n\n## Why It Matters\n\nBecause reasons.\n"}

	got := Merge(a, b)
	assert.Contains(t, got.Content, "A thing.")
	assert.Contains(t, got.Content, "Because reasons.")
}

func TestMerge_KeepsFrontmatterFromA(t *testing.T) {
	a := Page{Path: "p.md", Content: "---\ntitle: A\nlast_updated: 2026-01-01\n---\n\n## Definition\n\nA.\n"}
	b := Page{Path: "p.md", Content: "---\ntitle: B\nlast_updated: 2026-06-01\n---\n\n## Definition\n\nB.\n"}

	got := Merge(a, b)
	assert.Contains(t, got.Content, "title: A")
	assert.NotContains(t, got.Content, "title: B")
}
```

Add `"strings"` import to the test file.

- [ ] **Step 2: Run test to verify it fails**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/wiki/... -run TestMerge 2>&1
```

Expected: `undefined: Merge`

- [ ] **Step 3: Write merge.go**

```go
// ingestion/internal/wiki/merge.go
package wiki

import (
	"fmt"
	"strings"
)

var bulletSections = map[string]bool{
	"Related Concepts":                  true,
	"Related Entities":                  true,
	"Sources":                           true,
	"Key Claims":                        true,
	"Entities Mentioned":                true,
	"Concepts Introduced or Reinforced": true,
	"Chapters":                          true,
}

var appendSections = map[string]bool{
	"Evolving Notes":       true,
	"Updates":              true,
	"Open Questions Raised": true,
	"Open Questions":       true,
}

type section struct {
	heading string
	content string
}

// Merge combines two Page values with the same path.
// Frontmatter is taken from a. Sections are merged by strategy.
func Merge(a, b Page) Page {
	fmA, secsA := parseSections(a.Content)
	_, secsB := parseSections(b.Content)

	// Build heading → index map for A's sections.
	idx := make(map[string]int, len(secsA))
	for i, s := range secsA {
		idx[s.heading] = i
	}

	for _, sB := range secsB {
		i, exists := idx[sB.heading]
		if !exists {
			// New section not in A — append it.
			idx[sB.heading] = len(secsA)
			secsA = append(secsA, sB)
			continue
		}
		sA := secsA[i]
		switch {
		case bulletSections[sB.heading]:
			secsA[i].content = mergeBullets(sA.content, sB.content)
		case appendSections[sB.heading]:
			secsA[i].content = strings.TrimRight(sA.content, "\n") + "\n\n" + strings.TrimLeft(sB.content, "\n")
		// default: keep first — do nothing
		}
	}

	return Page{Path: a.Path, Content: rebuildContent(fmA, secsA)}
}

func parseSections(markdown string) (frontmatter string, sections []section) {
	lines := strings.Split(markdown, "\n")
	i := 0

	// Parse YAML frontmatter between --- markers.
	if i < len(lines) && strings.TrimSpace(lines[i]) == "---" {
		i++
		var fmLines []string
		for i < len(lines) {
			if strings.TrimSpace(lines[i]) == "---" {
				i++
				break
			}
			fmLines = append(fmLines, lines[i])
			i++
		}
		frontmatter = fmt.Sprintf("---\n%s\n---\n", strings.Join(fmLines, "\n"))
	}

	// Parse ## sections.
	var cur *section
	for ; i < len(lines); i++ {
		line := lines[i]
		if strings.HasPrefix(line, "## ") {
			if cur != nil {
				sections = append(sections, *cur)
			}
			cur = &section{heading: strings.TrimPrefix(line, "## ")}
		} else if cur != nil {
			cur.content += line + "\n"
		}
	}
	if cur != nil {
		sections = append(sections, *cur)
	}
	return
}

func rebuildContent(frontmatter string, sections []section) string {
	var sb strings.Builder
	sb.WriteString(frontmatter)
	for _, sec := range sections {
		fmt.Fprintf(&sb, "\n## %s\n\n%s", sec.heading, sec.content)
	}
	return sb.String()
}

func mergeBullets(a, b string) string {
	seen := make(map[string]bool)
	var lines []string
	for _, line := range strings.Split(a+b, "\n") {
		trimmed := strings.TrimSpace(line)
		if trimmed == "" || seen[trimmed] {
			continue
		}
		seen[trimmed] = true
		lines = append(lines, line)
	}
	return strings.Join(lines, "\n") + "\n"
}
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/wiki/... -v
```

Expected: all PASS.

- [ ] **Step 5: Commit**

```bash
git add ingestion/internal/wiki/merge.go ingestion/internal/wiki/merge_test.go
git commit -m "feat(ingestion): add wiki page merge logic"
```

---

## Task 5: wiki/inventory — load existing wiki pages

Reads `brain/wiki/` and builds a grouped slug index for injection into the LLM prompt.

**Files:**
- Create: `ingestion/internal/wiki/inventory.go`
- Create: `ingestion/internal/wiki/inventory_test.go`

- [ ] **Step 1: Write the failing test**

```go
// ingestion/internal/wiki/inventory_test.go
package wiki

import (
	"os"
	"path/filepath"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestLoadInventory(t *testing.T) {
	dir := t.TempDir()
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki", "concepts"), 0o755))
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki", "entities"), 0o755))
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki", "sources"), 0o755))

	require.NoError(t, os.WriteFile(
		filepath.Join(dir, "wiki", "concepts", "domain-driven-design.md"),
		[]byte("---\ntitle: Domain Driven Design\n---\n\n## Definition\n\nA thing.\n"),
		0o644,
	))
	require.NoError(t, os.WriteFile(
		filepath.Join(dir, "wiki", "entities", "ryan-singer.md"),
		[]byte("---\ntitle: Ryan Singer\n---\n\n## Description\n\nDesigner.\n"),
		0o644,
	))

	inv, err := LoadInventory(dir)
	require.NoError(t, err)

	assert.Len(t, inv[PageTypeConcept], 1)
	assert.Equal(t, "domain-driven-design", inv[PageTypeConcept][0].Slug)
	assert.Equal(t, "Domain Driven Design", inv[PageTypeConcept][0].Title)

	assert.Len(t, inv[PageTypeEntity], 1)
	assert.Equal(t, "ryan-singer", inv[PageTypeEntity][0].Slug)

	assert.Empty(t, inv[PageTypeSource])
}
```

- [ ] **Step 2: Run test to verify it fails**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/wiki/... -run TestLoadInventory 2>&1
```

Expected: `undefined: LoadInventory`

- [ ] **Step 3: Write inventory.go**

```go
// ingestion/internal/wiki/inventory.go
package wiki

import (
	"bufio"
	"os"
	"path/filepath"
	"strings"
)

// LoadInventory walks brain/wiki/ and returns all pages grouped by type.
func LoadInventory(brainDir string) (map[PageType][]Entry, error) {
	result := map[PageType][]Entry{
		PageTypeConcept: {},
		PageTypeEntity:  {},
		PageTypeSource:  {},
	}
	for pt := range result {
		dir := filepath.Join(brainDir, "wiki", string(pt))
		entries, err := os.ReadDir(dir)
		if os.IsNotExist(err) {
			continue
		}
		if err != nil {
			return nil, err
		}
		for _, e := range entries {
			if e.IsDir() || !strings.HasSuffix(e.Name(), ".md") {
				continue
			}
			slug := strings.TrimSuffix(e.Name(), ".md")
			path := filepath.Join(dir, e.Name())
			title := readTitle(path, slug)
			result[pt] = append(result[pt], Entry{Slug: slug, Title: title, Type: pt})
		}
	}
	return result, nil
}

// readTitle extracts the title from YAML frontmatter, falling back to slug.
func readTitle(path, fallback string) string {
	f, err := os.Open(path)
	if err != nil {
		return fallback
	}
	defer f.Close()

	scanner := bufio.NewScanner(f)
	inFM := false
	for scanner.Scan() {
		line := scanner.Text()
		if strings.TrimSpace(line) == "---" {
			if !inFM {
				inFM = true
				continue
			}
			break
		}
		if inFM {
			key, val, ok := strings.Cut(line, ":")
			if ok && strings.TrimSpace(key) == "title" {
				return strings.Trim(strings.TrimSpace(val), `"'`)
			}
		}
	}
	return fallback
}
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/wiki/... -v
```

Expected: all PASS.

- [ ] **Step 5: Commit**

```bash
git add ingestion/internal/wiki/inventory.go ingestion/internal/wiki/inventory_test.go
git commit -m "feat(ingestion): add wiki inventory loader"
```

---

## Task 6: wiki/index + wiki/log — index rebuilder and audit log

**Files:**
- Create: `ingestion/internal/wiki/index.go`
- Create: `ingestion/internal/wiki/log.go`
- Create: `ingestion/internal/wiki/index_test.go`

- [ ] **Step 1: Write failing tests**

```go
// ingestion/internal/wiki/index_test.go
package wiki

import (
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func setupWikiDir(t *testing.T) string {
	t.Helper()
	dir := t.TempDir()
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki", "concepts"), 0o755))
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki", "entities"), 0o755))
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "wiki", "sources"), 0o755))
	require.NoError(t, os.WriteFile(
		filepath.Join(dir, "wiki", "concepts", "tdd.md"),
		[]byte("---\ntitle: TDD\n---\n\n## Definition\n\nTest-driven development is a discipline.\n"),
		0o644,
	))
	return dir
}

func TestRebuildIndex(t *testing.T) {
	dir := setupWikiDir(t)
	require.NoError(t, RebuildIndex(dir, "2026-04-22"))

	content, err := os.ReadFile(filepath.Join(dir, "wiki", "index.md"))
	require.NoError(t, err)
	s := string(content)
	assert.Contains(t, s, "# Wiki Index")
	assert.Contains(t, s, "2026-04-22")
	assert.Contains(t, s, "[[tdd|TDD]]")
	assert.Contains(t, s, "## Concepts")
}

func TestAppendLog(t *testing.T) {
	dir := t.TempDir()
	require.NoError(t, AppendLog(dir, "shape-up-book",
		[]string{"wiki/sources/shape-up.md", "wiki/concepts/betting-table.md"},
		nil, "2026-04-22"))

	content, err := os.ReadFile(filepath.Join(dir, "log.md"))
	require.NoError(t, err)
	s := string(content)
	assert.Contains(t, s, "shape-up-book")
	assert.Contains(t, s, "wiki/sources/shape-up.md")
	assert.True(t, strings.HasPrefix(s, "## 2026-04-22"))
}

func TestAppendLog_AppendsOnSecondCall(t *testing.T) {
	dir := t.TempDir()
	require.NoError(t, AppendLog(dir, "source-a", []string{"wiki/sources/a.md"}, nil, "2026-04-22"))
	require.NoError(t, AppendLog(dir, "source-b", []string{"wiki/sources/b.md"}, nil, "2026-04-22"))

	content, err := os.ReadFile(filepath.Join(dir, "log.md"))
	require.NoError(t, err)
	assert.Contains(t, string(content), "source-a")
	assert.Contains(t, string(content), "source-b")
}
```

- [ ] **Step 2: Run test to verify it fails**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/wiki/... -run "TestRebuildIndex|TestAppendLog" 2>&1
```

Expected: `undefined: RebuildIndex`

- [ ] **Step 3: Write index.go**

```go
// ingestion/internal/wiki/index.go
package wiki

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
)

// RebuildIndex writes brain/wiki/index.md from the current wiki contents.
func RebuildIndex(brainDir, date string) error {
	inv, err := LoadInventory(brainDir)
	if err != nil {
		return fmt.Errorf("load inventory: %w", err)
	}

	total := len(inv[PageTypeConcept]) + len(inv[PageTypeEntity]) + len(inv[PageTypeSource])
	var sb strings.Builder
	fmt.Fprintf(&sb, "# Wiki Index\n\n")
	fmt.Fprintf(&sb, "_Updated: %s — %d pages (%d concepts, %d entities, %d sources)_\n\n",
		date, total,
		len(inv[PageTypeConcept]),
		len(inv[PageTypeEntity]),
		len(inv[PageTypeSource]))

	for _, pt := range []PageType{PageTypeConcept, PageTypeEntity, PageTypeSource} {
		entries := inv[pt]
		if len(entries) == 0 {
			continue
		}
		fmt.Fprintf(&sb, "## %s\n\n", strings.Title(string(pt)))
		for _, e := range entries {
			summary := pageFirstSentence(brainDir, e)
			fmt.Fprintf(&sb, "- [[%s|%s]] — %s\n", e.Slug, e.Title, summary)
		}
		sb.WriteString("\n")
	}

	dest := filepath.Join(brainDir, "wiki", "index.md")
	return os.WriteFile(dest, []byte(sb.String()), 0o644)
}

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 ""
	}
	// Skip frontmatter, find first non-empty line after a ## heading.
	parts := strings.SplitN(string(content), "---", 3)
	body := string(content)
	if len(parts) == 3 {
		body = parts[2]
	}
	for _, line := range strings.Split(body, "\n") {
		line = strings.TrimSpace(line)
		if line == "" || strings.HasPrefix(line, "#") {
			continue
		}
		if len(line) > 100 {
			return line[:100] + "…"
		}
		return line
	}
	return ""
}
```

- [ ] **Step 4: Write log.go**

```go
// ingestion/internal/wiki/log.go
package wiki

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
)

// AppendLog appends one ingestion record to brain/log.md.
func AppendLog(brainDir, source string, pages, warnings []string, date string) error {
	var sb strings.Builder
	fmt.Fprintf(&sb, "## %s — ingest\n\n", date)
	fmt.Fprintf(&sb, "- **Source:** %s\n", source)
	if len(pages) > 0 {
		sb.WriteString("- **Pages written:**\n")
		for _, p := range pages {
			fmt.Fprintf(&sb, "  - %s\n", p)
		}
	}
	if len(warnings) > 0 {
		sb.WriteString("- **Warnings:**\n")
		for _, w := range warnings {
			fmt.Fprintf(&sb, "  - %s\n", w)
		}
	}
	sb.WriteString("\n")

	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 log: %w", err)
	}
	defer f.Close()
	_, err = f.WriteString(sb.String())
	return err
}
```

- [ ] **Step 5: Run tests to verify they pass**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/wiki/... -v
```

Expected: all PASS. (Note: `strings.Title` may show a deprecation warning — it is fine for this use case.)

- [ ] **Step 6: Commit**

```bash
git add ingestion/internal/wiki/index.go ingestion/internal/wiki/log.go ingestion/internal/wiki/index_test.go
git commit -m "feat(ingestion): add wiki index rebuilder and audit log"
```

---

## Task 7: llm/client — OpenAI-compatible HTTP client

**Files:**
- Create: `ingestion/internal/llm/client.go`
- Create: `ingestion/internal/llm/client_test.go`

- [ ] **Step 1: Write the failing test**

```go
// ingestion/internal/llm/client_test.go
package llm

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func mockLLMServer(t *testing.T, response string) *httptest.Server {
	t.Helper()
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		assert.Equal(t, "/chat/completions", r.URL.Path)
		assert.Equal(t, "application/json", r.Header.Get("Content-Type"))
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]any{
			"choices": []map[string]any{
				{"message": map[string]any{"role": "assistant", "content": response}},
			},
		})
	}))
}

func TestClient_Complete(t *testing.T) {
	srv := mockLLMServer(t, "hello world")
	defer srv.Close()

	c := New(srv.URL, "", "test-model", 10*time.Second)
	got, err := c.Complete(context.Background(), "you are helpful", "say hello")
	require.NoError(t, err)
	assert.Equal(t, "hello world", got)
}

func TestClient_ReturnsErrorOnNon200(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "overloaded", http.StatusServiceUnavailable)
	}))
	defer srv.Close()

	c := New(srv.URL, "", "test-model", 10*time.Second)
	_, err := c.Complete(context.Background(), "sys", "user")
	assert.Error(t, err)
}

func TestClient_SendsAuthHeader(t *testing.T) {
	var gotAuth string
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gotAuth = r.Header.Get("Authorization")
		json.NewEncoder(w).Encode(map[string]any{
			"choices": []map[string]any{{"message": map[string]any{"content": "ok"}}},
		})
	}))
	defer srv.Close()

	c := New(srv.URL, "my-key", "test-model", 10*time.Second)
	_, err := c.Complete(context.Background(), "sys", "user")
	require.NoError(t, err)
	assert.Equal(t, "Bearer my-key", gotAuth)
}
```

- [ ] **Step 2: Run test to verify it fails**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/llm/... 2>&1
```

Expected: `undefined: New`

- [ ] **Step 3: Write client.go**

```go
// ingestion/internal/llm/client.go
package llm

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"
	"time"
)

// Client calls an OpenAI-compatible chat completions endpoint.
type Client struct {
	baseURL    string
	apiKey     string
	model      string
	httpClient *http.Client
}

// New constructs a Client.
func New(baseURL, apiKey, model string, timeout time.Duration) *Client {
	return &Client{
		baseURL:    strings.TrimRight(baseURL, "/"),
		apiKey:     apiKey,
		model:      model,
		httpClient: &http.Client{Timeout: timeout},
	}
}

type chatRequest struct {
	Model       string    `json:"model"`
	Messages    []message `json:"messages"`
	Temperature float64   `json:"temperature"`
}

type message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type chatResponse struct {
	Choices []struct {
		Message message `json:"message"`
	} `json:"choices"`
}

// Complete sends a system + user message and returns the assistant's reply.
func (c *Client) Complete(ctx context.Context, system, user string) (string, error) {
	body := chatRequest{
		Model: c.model,
		Messages: []message{
			{Role: "system", Content: system},
			{Role: "user", Content: user},
		},
		Temperature: 0.2,
	}
	b, err := json.Marshal(body)
	if err != nil {
		return "", fmt.Errorf("marshal request: %w", err)
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.baseURL+"/chat/completions", bytes.NewReader(b))
	if err != nil {
		return "", fmt.Errorf("build request: %w", err)
	}
	req.Header.Set("Content-Type", "application/json")
	if c.apiKey != "" {
		req.Header.Set("Authorization", "Bearer "+c.apiKey)
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return "", fmt.Errorf("call LLM: %w", err)
	}
	defer resp.Body.Close()

	out, err := io.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("read response: %w", err)
	}
	if resp.StatusCode != http.StatusOK {
		return "", fmt.Errorf("LLM returned %d: %s", resp.StatusCode, out)
	}

	var cr chatResponse
	if err := json.Unmarshal(out, &cr); err != nil {
		return "", fmt.Errorf("parse response: %w", err)
	}
	if len(cr.Choices) == 0 {
		return "", fmt.Errorf("LLM returned no choices")
	}
	return cr.Choices[0].Message.Content, nil
}
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/llm/... -v
```

Expected: all PASS.

- [ ] **Step 5: Commit**

```bash
git add ingestion/internal/llm/
git commit -m "feat(ingestion): add OpenAI-compatible LLM HTTP client"
```

---

## Task 8: pipeline/chunk + pipeline/parse

**Files:**
- Create: `ingestion/internal/pipeline/chunk.go`
- Create: `ingestion/internal/pipeline/chunk_test.go`
- Create: `ingestion/internal/pipeline/parse.go`
- Create: `ingestion/internal/pipeline/parse_test.go`

- [ ] **Step 1: Write failing tests**

```go
// ingestion/internal/pipeline/chunk_test.go
package pipeline

import (
	"strings"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestChunk_NoChunkingWhenZero(t *testing.T) {
	content := strings.Repeat("word ", 1000)
	chunks := Chunk(content, 0)
	assert.Len(t, chunks, 1)
	assert.Equal(t, strings.TrimSpace(content), chunks[0])
}

func TestChunk_SplitsAtParagraph(t *testing.T) {
	// Two paragraphs; each ~30 chars. maxSize = 40 should split them.
	content := "First paragraph here.\n\nSecond paragraph here."
	chunks := Chunk(content, 40)
	assert.Len(t, chunks, 2)
	assert.Equal(t, "First paragraph here.", chunks[0])
	assert.Equal(t, "Second paragraph here.", chunks[1])
}

func TestChunk_SingleLargeParagraph(t *testing.T) {
	// A single paragraph larger than maxSize stays as one chunk.
	content := strings.Repeat("x", 100)
	chunks := Chunk(content, 50)
	assert.Len(t, chunks, 1)
}
```

```go
// ingestion/internal/pipeline/parse_test.go
package pipeline

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
)

func TestParsePages_ValidJSON(t *testing.T) {
	input := `[{"path":"wiki/sources/foo.md","content":"# Foo"},{"path":"wiki/concepts/bar.md","content":"# Bar"}]`
	pages, warnings := ParsePages(input)
	require.Len(t, pages, 2)
	assert.Empty(t, warnings)
	assert.Equal(t, "wiki/sources/foo.md", pages[0].Path)
}

func TestParsePages_StripsFences(t *testing.T) {
	input := "```json\n[{\"path\":\"wiki/sources/foo.md\",\"content\":\"# Foo\"}]\n```"
	pages, warnings := ParsePages(input)
	assert.Len(t, pages, 1)
	assert.Empty(t, warnings)
}

func TestParsePages_TruncationRecovery(t *testing.T) {
	// Valid first object, second truncated mid-way.
	input := `[{"path":"wiki/sources/foo.md","content":"# Foo"},{"path":"wiki/concepts/bar.md","content":"trunc`
	pages, warnings := ParsePages(input)
	require.Len(t, pages, 1)
	assert.Equal(t, "wiki/sources/foo.md", pages[0].Path)
	assert.NotEmpty(t, warnings)
}

func TestParsePages_EmptyInput(t *testing.T) {
	pages, warnings := ParsePages("")
	assert.Empty(t, pages)
	assert.NotEmpty(t, warnings)
}

// Ensure wiki.Page is used correctly (compile-time check).
var _ []wiki.Page = nil
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/pipeline/... 2>&1
```

Expected: `undefined: Chunk` and `undefined: ParsePages`

- [ ] **Step 3: Write chunk.go**

```go
// ingestion/internal/pipeline/chunk.go
package pipeline

import "strings"

// Chunk splits content into pieces of at most maxSize bytes, splitting at
// paragraph boundaries (\n\n). If maxSize <= 0, returns content as one chunk.
func Chunk(content string, maxSize int) []string {
	content = strings.TrimSpace(content)
	if maxSize <= 0 || len(content) <= maxSize {
		return []string{content}
	}

	paragraphs := strings.Split(content, "\n\n")
	var chunks []string
	var cur strings.Builder

	for _, para := range paragraphs {
		para = strings.TrimSpace(para)
		if para == "" {
			continue
		}
		// If adding this paragraph would exceed maxSize and we already have content,
		// flush the current chunk first.
		addition := para
		if cur.Len() > 0 {
			addition = "\n\n" + para
		}
		if cur.Len() > 0 && cur.Len()+len(addition) > maxSize {
			chunks = append(chunks, cur.String())
			cur.Reset()
			cur.WriteString(para)
		} else {
			cur.WriteString(addition)
		}
	}
	if cur.Len() > 0 {
		chunks = append(chunks, cur.String())
	}
	return chunks
}
```

- [ ] **Step 4: Write parse.go**

```go
// ingestion/internal/pipeline/parse.go
package pipeline

import (
	"encoding/json"
	"fmt"
	"strings"

	"github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
)

// ParsePages parses LLM output as a JSON array of {path, content} objects.
// If the array is truncated mid-object (token limit), it salvages all complete objects.
func ParsePages(output string) ([]wiki.Page, []string) {
	output = strings.TrimSpace(output)
	if output == "" {
		return nil, []string{"LLM returned empty output"}
	}

	output = stripFences(output)

	var pages []wiki.Page
	if err := json.Unmarshal([]byte(output), &pages); err == nil {
		return pages, nil
	}

	// Truncation recovery: find last `}` that closes a complete object.
	idx := strings.LastIndex(output, "}")
	if idx < 0 {
		return nil, []string{"LLM output contained no complete JSON objects"}
	}

	start := strings.Index(output, "[")
	if start < 0 {
		return nil, []string{"LLM output contained no JSON array opening bracket"}
	}

	candidate := output[start:idx+1] + "]"
	if err := json.Unmarshal([]byte(candidate), &pages); err != nil {
		return nil, []string{fmt.Sprintf("truncation recovery failed: %v", err)}
	}

	return pages, []string{fmt.Sprintf("LLM output was truncated; recovered %d page(s)", len(pages))}
}

func stripFences(s string) string {
	for _, prefix := range []string{"```json\n", "```json\r\n", "```\n", "```\r\n"} {
		if strings.HasPrefix(s, prefix) {
			s = strings.TrimPrefix(s, prefix)
			s = strings.TrimSuffix(strings.TrimSpace(s), "```")
			return strings.TrimSpace(s)
		}
	}
	return s
}
```

- [ ] **Step 5: Run tests to verify they pass**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/pipeline/... -v
```

Expected: all PASS.

- [ ] **Step 6: Commit**

```bash
git add ingestion/internal/pipeline/chunk.go ingestion/internal/pipeline/chunk_test.go \
        ingestion/internal/pipeline/parse.go ingestion/internal/pipeline/parse_test.go
git commit -m "feat(ingestion): add content chunking and LLM JSON output parser"
```

---

## Task 9: pipeline/prompt + pipeline/pipeline — prompt builder and orchestrator

**Files:**
- Create: `ingestion/internal/pipeline/prompt.go`
- Create: `ingestion/internal/pipeline/pipeline.go`
- Create: `ingestion/internal/pipeline/pipeline_test.go`

- [ ] **Step 1: Write the failing integration test**

```go
// ingestion/internal/pipeline/pipeline_test.go
package pipeline

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/mathiasbq/hyperguild/ingestion/internal/llm"
	"github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
)

func TestRun_WritesPages(t *testing.T) {
	brainDir := t.TempDir()
	for _, sub := range []string{"wiki/concepts", "wiki/entities", "wiki/sources"} {
		require.NoError(t, os.MkdirAll(filepath.Join(brainDir, sub), 0o755))
	}

	// Mock LLM returns two pages.
	llmResponse := mustJSON([]wiki.Page{
		{
			Path:    "wiki/sources/test-article.md",
			Content: "---\ntitle: Test Article\ntype: article\ndomain: software-engineering\ndate_ingested: 2026-04-22\nlast_updated: 2026-04-22\naliases:\n  - Test Article\n---\n\n## Summary\n\nA test article.\n\n## Key Claims\n\n- It tests things.\n\n## Concepts Introduced or Reinforced\n\n## Entities Mentioned\n\n## Open Questions Raised\n",
		},
		{
			Path:    "wiki/concepts/testing.md",
			Content: "---\ntitle: Testing\ndomain: software-engineering\nlast_updated: 2026-04-22\naliases:\n  - Testing\n---\n\n## Definition\n\nThe practice of verifying software.\n\n## Why It Matters\n\nCatches bugs.\n\n## Related Concepts\n\n## Related Entities\n\n## Sources\n\n## Evolving Notes\n",
		},
	})

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(map[string]any{
			"choices": []map[string]any{
				{"message": map[string]any{"role": "assistant", "content": llmResponse}},
			},
		})
	}))
	defer srv.Close()

	cfg := Config{
		Complete:  llm.New(srv.URL, "", "test-model", 30*time.Second).Complete,
		ChunkSize: 0,
	}

	result, err := Run(context.Background(), cfg, brainDir, "An article about testing.", "test-article", false)
	require.NoError(t, err)
	assert.Len(t, result.Pages, 2)
	assert.Empty(t, result.Warnings)

	// Files must exist on disk.
	_, err = os.Stat(filepath.Join(brainDir, "wiki", "sources", "test-article.md"))
	require.NoError(t, err)
	_, err = os.Stat(filepath.Join(brainDir, "wiki", "concepts", "testing.md"))
	require.NoError(t, err)

	// Index must be rebuilt.
	_, err = os.Stat(filepath.Join(brainDir, "wiki", "index.md"))
	require.NoError(t, err)

	// Log must be appended.
	_, err = os.Stat(filepath.Join(brainDir, "log.md"))
	require.NoError(t, err)
}

func TestRun_DryRunDoesNotWrite(t *testing.T) {
	brainDir := t.TempDir()
	for _, sub := range []string{"wiki/concepts", "wiki/entities", "wiki/sources"} {
		require.NoError(t, os.MkdirAll(filepath.Join(brainDir, sub), 0o755))
	}

	llmResponse := mustJSON([]wiki.Page{{
		Path:    "wiki/sources/foo.md",
		Content: "---\ntitle: Foo\n---\n\n## Summary\n\nFoo.\n",
	}})

	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		json.NewEncoder(w).Encode(map[string]any{
			"choices": []map[string]any{{"message": map[string]any{"content": llmResponse}}},
		})
	}))
	defer srv.Close()

	cfg := Config{Complete: llm.New(srv.URL, "", "m", 30*time.Second).Complete}
	result, err := Run(context.Background(), cfg, brainDir, "foo content", "foo", true)
	require.NoError(t, err)
	assert.Len(t, result.Pages, 1)

	// No files written in dry-run.
	_, err = os.Stat(filepath.Join(brainDir, "wiki", "sources", "foo.md"))
	assert.True(t, os.IsNotExist(err))
}

func mustJSON(v any) string {
	b, _ := json.Marshal(v)
	return string(b)
}
```

- [ ] **Step 2: Run test to verify it fails**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/pipeline/... -run "TestRun" 2>&1
```

Expected: `undefined: Run` and `undefined: Config`

- [ ] **Step 3: Write prompt.go**

```go
// ingestion/internal/pipeline/prompt.go
package pipeline

import (
	"fmt"
	"strings"
	"time"

	"github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
)

const systemPrompt = `You are a wiki agent. Read the source material and produce structured wiki pages following the schema provided.

Output ONLY a valid JSON array — no markdown fences, no other text before or after.
Each element must have:
  "path"    — relative path within the wiki, e.g. "wiki/sources/foo.md"
  "content" — full markdown content of the page including YAML frontmatter

Follow the schema strictly: correct frontmatter fields, wikilinks as [[slug|Display Text]],
dates in YYYY-MM-DD format, and paraphrase rather than quoting verbatim.`

// BuildPrompt constructs the user prompt for a single chunk.
func BuildPrompt(schema, source, content string, inventory map[wiki.PageType][]wiki.Entry) string {
	var sb strings.Builder

	fmt.Fprintf(&sb, "Today's date is %s.\n\n", time.Now().UTC().Format("2006-01-02"))

	sb.WriteString("## Schema\n\n")
	sb.WriteString(schema)
	sb.WriteString("\n\n")

	sb.WriteString("## Existing wiki pages\n\n")
	sb.WriteString("Link ONLY to pages that appear in this inventory or that you are creating in this response.\n\n")

	for _, pt := range []wiki.PageType{wiki.PageTypeConcept, wiki.PageTypeEntity, wiki.PageTypeSource} {
		entries := inventory[pt]
		label := strings.ToTitle(string(pt))
		if len(entries) == 0 {
			fmt.Fprintf(&sb, "%s — (none yet)\n\n", label)
			continue
		}
		fmt.Fprintf(&sb, "%s — link ONLY under the matching section:\n", label)
		for _, e := range entries {
			fmt.Fprintf(&sb, "  - [[%s|%s]]\n", e.Slug, e.Title)
		}
		sb.WriteString("\n")
	}

	sb.WriteString("## Non-negotiable rules\n\n")
	sb.WriteString("1. Output ONLY a valid JSON array — no prose, no fences.\n")
	sb.WriteString("2. Slugs are kebab-case: lowercase, spaces→hyphens, no special chars.\n")
	sb.WriteString("3. Wikilinks: [[slug|Display Text]] — the pipe is required.\n")
	sb.WriteString("4. Section links must match their section type.\n")
	sb.WriteString("5. One source page per book — update it if inventory shows it exists.\n\n")

	fmt.Fprintf(&sb, "## Source: %s\n\n", source)
	sb.WriteString(content)

	return sb.String()
}
```

- [ ] **Step 4: Write pipeline.go**

```go
// ingestion/internal/pipeline/pipeline.go
package pipeline

import (
	"context"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
)

// CompleteFunc is the function signature for LLM calls.
type CompleteFunc func(ctx context.Context, system, user string) (string, error)

// Config holds pipeline configuration.
type Config struct {
	Complete  CompleteFunc
	ChunkSize int    // 0 = no chunking
	Schema    string // overrides brain/CLAUDE.md when set (used in tests)
}

// Result is the outcome of a pipeline run.
type Result struct {
	Pages    []string // relative paths written (or would-be written in dry-run)
	Warnings []string
}

// Run ingests content and writes structured wiki pages to brainDir/wiki/.
// In dry-run mode, pages are returned but not written to disk.
func Run(ctx context.Context, cfg Config, brainDir, content, source string, dryRun bool) (Result, error) {
	// 1. Load inventory.
	inventory, err := wiki.LoadInventory(brainDir)
	if err != nil {
		return Result{}, fmt.Errorf("load inventory: %w", err)
	}

	// 2. Load schema.
	schema := cfg.Schema
	if schema == "" {
		schema = loadSchema(brainDir)
	}

	// 3. Chunk.
	chunks := Chunk(content, cfg.ChunkSize)

	// 4 & 5. Call LLM per chunk, parse output.
	var allPages []wiki.Page
	var allWarnings []string

	for _, chunk := range chunks {
		userPrompt := BuildPrompt(schema, source, chunk, inventory)
		output, err := cfg.Complete(ctx, systemPrompt, userPrompt)
		if err != nil {
			return Result{}, fmt.Errorf("LLM call: %w", err)
		}
		pages, warnings := ParsePages(output)
		allPages = append(allPages, pages...)
		allWarnings = append(allWarnings, warnings...)
	}

	// 6. Merge pages with the same path.
	merged := mergeAll(allPages)

	// 7. Write (or preview in dry-run).
	date := time.Now().UTC().Format("2006-01-02")
	var written []string

	for _, page := range merged {
		if !dryRun {
			dest := filepath.Join(brainDir, filepath.FromSlash(page.Path))
			if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
				return Result{}, fmt.Errorf("mkdir for %s: %w", page.Path, err)
			}
			if err := os.WriteFile(dest, []byte(page.Content), 0o644); err != nil {
				return Result{}, fmt.Errorf("write %s: %w", page.Path, err)
			}
		}
		written = append(written, page.Path)
	}

	if !dryRun {
		// 8. Rebuild index.
		if err := wiki.RebuildIndex(brainDir, date); err != nil {
			allWarnings = append(allWarnings, fmt.Sprintf("rebuild index: %v", err))
		}
		// 9. Append log.
		if err := wiki.AppendLog(brainDir, source, written, allWarnings, date); err != nil {
			allWarnings = append(allWarnings, fmt.Sprintf("append log: %v", err))
		}
	}

	return Result{Pages: written, Warnings: allWarnings}, nil
}

// mergeAll deduplicates pages by path, merging content from later occurrences.
func mergeAll(pages []wiki.Page) []wiki.Page {
	order := make([]string, 0, len(pages))
	byPath := make(map[string]wiki.Page, len(pages))
	for _, p := range pages {
		if _, seen := byPath[p.Path]; !seen {
			order = append(order, p.Path)
			byPath[p.Path] = p
		} else {
			byPath[p.Path] = wiki.Merge(byPath[p.Path], p)
		}
	}
	result := make([]wiki.Page, 0, len(order))
	for _, path := range order {
		result = append(result, byPath[path])
	}
	return result
}

// defaultSchema is embedded when brain/CLAUDE.md is absent.
const defaultSchema = `# Brain Wiki Schema
See brain/CLAUDE.md for the full schema. Using minimal fallback.
Three page types: wiki/sources/, wiki/concepts/, wiki/entities/.
`

func loadSchema(brainDir string) string {
	b, err := os.ReadFile(filepath.Join(brainDir, "CLAUDE.md"))
	if err != nil {
		return defaultSchema
	}
	return strings.TrimSpace(string(b))
}
```

- [ ] **Step 5: Run tests to verify they pass**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/pipeline/... -v
```

Expected: all PASS.

- [ ] **Step 6: Commit**

```bash
git add ingestion/internal/pipeline/
git commit -m "feat(ingestion): add pipeline orchestrator with prompt builder"
```

---

## Task 10: api — /ingest and /ingest-path handlers + main.go wiring

**Files:**
- Modify: `ingestion/internal/api/handler.go`
- Modify: `ingestion/internal/api/handler_test.go`
- Modify: `ingestion/cmd/server/main.go`

- [ ] **Step 1: Write failing handler tests**

Add these test functions to `ingestion/internal/api/handler_test.go`.

First update the `setup` helper to accept `pipeline.Config` — change the existing `setup` function:

```go
func setup(t *testing.T) (string, *api.Handler) {
	t.Helper()
	dir := t.TempDir()
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "knowledge"), 0o755))
	require.NoError(t, os.WriteFile(
		filepath.Join(dir, "knowledge", "tdd.md"),
		[]byte("---\ntitle: TDD\ndomain: software\n---\n\nTest-driven development is a discipline.\n"),
		0o644,
	))
	logger := slog.New(slog.NewTextHandler(os.Stderr, nil))
	return dir, api.NewHandler(dir, logger, pipeline.Config{})
}
```

Then add the new test functions at the bottom of the file:

```go
func TestIngest_RequiresContent(t *testing.T) {
	_, h := setup(t)
	body, _ := json.Marshal(map[string]any{"source": "test"})
	req := httptest.NewRequest(http.MethodPost, "/ingest", bytes.NewReader(body))
	rec := httptest.NewRecorder()
	h.Ingest(rec, req)
	assert.Equal(t, http.StatusBadRequest, rec.Code)
}

func TestIngest_RequiresSource(t *testing.T) {
	_, h := setup(t)
	body, _ := json.Marshal(map[string]any{"content": "something"})
	req := httptest.NewRequest(http.MethodPost, "/ingest", bytes.NewReader(body))
	rec := httptest.NewRecorder()
	h.Ingest(rec, req)
	assert.Equal(t, http.StatusBadRequest, rec.Code)
}

func TestIngestPath_RequiresPath(t *testing.T) {
	_, h := setup(t)
	body, _ := json.Marshal(map[string]any{})
	req := httptest.NewRequest(http.MethodPost, "/ingest-path", bytes.NewReader(body))
	rec := httptest.NewRecorder()
	h.IngestPath(rec, req)
	assert.Equal(t, http.StatusBadRequest, rec.Code)
}

func TestIngestPath_RejectsNonexistentPath(t *testing.T) {
	_, h := setup(t)
	body, _ := json.Marshal(map[string]any{"path": "/does/not/exist.md"})
	req := httptest.NewRequest(http.MethodPost, "/ingest-path", bytes.NewReader(body))
	rec := httptest.NewRecorder()
	h.IngestPath(rec, req)
	assert.Equal(t, http.StatusBadRequest, rec.Code)
}
```

Also add these imports to `handler_test.go`:
```go
import (
    "github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
)
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/api/... 2>&1
```

Expected: compile error — `NewHandler` wrong number of args, `Ingest`/`IngestPath` undefined.

- [ ] **Step 3: Update handler.go**

Replace the full contents of `ingestion/internal/api/handler.go`:

```go
// ingestion/internal/api/handler.go
package api

import (
	"context"
	"encoding/json"
	"fmt"
	"log/slog"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
	"github.com/mathiasbq/hyperguild/ingestion/internal/search"
)

// Handler serves the ingestion HTTP API.
type Handler struct {
	brainDir string
	logger   *slog.Logger
	pipeline pipeline.Config
}

// NewHandler constructs a Handler.
func NewHandler(brainDir string, logger *slog.Logger, pc pipeline.Config) *Handler {
	return &Handler{brainDir: brainDir, logger: logger, pipeline: pc}
}

// --- /query ---

type queryRequest struct {
	Query string `json:"query"`
	Limit int    `json:"limit,omitempty"`
}

func (h *Handler) Query(w http.ResponseWriter, r *http.Request) {
	var req queryRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "invalid JSON", http.StatusBadRequest)
		return
	}
	if strings.TrimSpace(req.Query) == "" {
		http.Error(w, "query is required", http.StatusBadRequest)
		return
	}
	if req.Limit == 0 {
		req.Limit = 5
	}
	results, err := search.Query(h.brainDir, req.Query, req.Limit)
	if err != nil {
		h.logger.Error("query failed", "err", err)
		http.Error(w, "search error", http.StatusInternalServerError)
		return
	}
	writeJSON(w, map[string]any{"results": results})
}

// --- /write ---

type writeRequest struct {
	Content  string `json:"content"`
	Filename string `json:"filename,omitempty"`
	Type     string `json:"type,omitempty"`
	Domain   string `json:"domain,omitempty"`
}

func (h *Handler) Write(w http.ResponseWriter, r *http.Request) {
	var req writeRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "invalid JSON", http.StatusBadRequest)
		return
	}
	if req.Content == "" {
		http.Error(w, "content is required", http.StatusBadRequest)
		return
	}

	filename := req.Filename
	if filename == "" {
		filename = fmt.Sprintf("%s-auto.md", time.Now().UTC().Format("2006-01-02-150405"))
	}

	rawDir := filepath.Join(h.brainDir, "knowledge")
	if err := os.MkdirAll(rawDir, 0o755); err != nil {
		http.Error(w, "failed to create raw dir", http.StatusInternalServerError)
		return
	}

	finalContent := req.Content
	if req.Type != "" || req.Domain != "" {
		var fm strings.Builder
		fm.WriteString("---\n")
		if req.Type != "" {
			fmt.Fprintf(&fm, "type: %s\n", req.Type)
		}
		if req.Domain != "" {
			fmt.Fprintf(&fm, "domain: %s\n", req.Domain)
		}
		fm.WriteString("---\n")
		finalContent = fm.String() + req.Content
	}

	base := filepath.Base(filename)
	if !strings.HasSuffix(base, ".md") {
		base += ".md"
	}
	dest := filepath.Join(rawDir, base)
	if err := os.WriteFile(dest, []byte(finalContent), 0o644); err != nil {
		h.logger.Error("write failed", "err", err)
		http.Error(w, "write error", http.StatusInternalServerError)
		return
	}

	rel, _ := filepath.Rel(h.brainDir, dest)
	writeJSON(w, map[string]string{"path": filepath.ToSlash(rel)})
}

// --- /ingest ---

type ingestRequest struct {
	Content string `json:"content"`
	Source  string `json:"source"`
	DryRun  bool   `json:"dry_run,omitempty"`
}

func (h *Handler) Ingest(w http.ResponseWriter, r *http.Request) {
	var req ingestRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "invalid JSON", http.StatusBadRequest)
		return
	}
	if req.Content == "" {
		http.Error(w, "content is required", http.StatusBadRequest)
		return
	}
	if req.Source == "" {
		http.Error(w, "source is required", http.StatusBadRequest)
		return
	}

	result, err := pipeline.Run(r.Context(), h.pipeline, h.brainDir, req.Content, req.Source, req.DryRun)
	if err != nil {
		h.logger.Error("ingest failed", "source", req.Source, "err", err)
		http.Error(w, "ingest error: "+err.Error(), http.StatusInternalServerError)
		return
	}
	writeJSON(w, map[string]any{"pages": result.Pages, "warnings": result.Warnings})
}

// --- /ingest-path ---

type ingestPathRequest struct {
	Path   string `json:"path"`
	Source string `json:"source,omitempty"`
	DryRun bool   `json:"dry_run,omitempty"`
}

func (h *Handler) IngestPath(w http.ResponseWriter, r *http.Request) {
	var req ingestPathRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "invalid JSON", http.StatusBadRequest)
		return
	}
	if req.Path == "" {
		http.Error(w, "path is required", http.StatusBadRequest)
		return
	}

	info, err := os.Stat(req.Path)
	if err != nil {
		http.Error(w, "path not found: "+req.Path, http.StatusBadRequest)
		return
	}

	var files []string
	if info.IsDir() {
		files, err = collectFiles(req.Path)
		if err != nil {
			h.logger.Error("collect files failed", "path", req.Path, "err", err)
			http.Error(w, "failed to read directory", http.StatusInternalServerError)
			return
		}
	} else {
		files = []string{req.Path}
	}

	var allPages []string
	var allWarnings []string

	for _, f := range files {
		content, err := os.ReadFile(f)
		if err != nil {
			allWarnings = append(allWarnings, fmt.Sprintf("skip %s: %v", f, err))
			continue
		}
		source := req.Source
		if source == "" {
			source = sourceFromFilename(filepath.Base(f))
		}
		result, err := pipeline.Run(r.Context(), h.pipeline, h.brainDir, string(content), source, req.DryRun)
		if err != nil {
			h.logger.Error("ingest-path failed", "file", f, "err", err)
			allWarnings = append(allWarnings, fmt.Sprintf("ingest %s: %v", f, err))
			continue
		}
		allPages = append(allPages, result.Pages...)
		allWarnings = append(allWarnings, result.Warnings...)
	}

	writeJSON(w, map[string]any{"pages": allPages, "warnings": allWarnings})
}

var supportedExts = map[string]bool{".md": true, ".txt": true, ".pdf": true}

func collectFiles(dir string) ([]string, error) {
	var files []string
	err := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
		if err != nil {
			return nil
		}
		if d.IsDir() {
			return nil
		}
		if supportedExts[strings.ToLower(filepath.Ext(path))] {
			files = append(files, path)
		}
		return nil
	})
	return files, err
}

func sourceFromFilename(filename string) string {
	name := strings.TrimSuffix(filename, filepath.Ext(filename))
	words := strings.FieldsFunc(name, func(r rune) bool { return r == '-' || r == '_' })
	for i, w := range words {
		if len(w) > 0 {
			words[i] = strings.ToUpper(w[:1]) + w[1:]
		}
	}
	return strings.Join(words, " ")
}

func writeJSON(w http.ResponseWriter, v any) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(v) //nolint:errcheck
}
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/api/... -v
```

Expected: all PASS.

- [ ] **Step 5: Update main.go**

Replace `ingestion/cmd/server/main.go`:

```go
// ingestion/cmd/server/main.go
package main

import (
	"context"
	"log/slog"
	"net/http"
	"os"
	"strconv"
	"time"

	"github.com/mathiasbq/hyperguild/ingestion/internal/api"
	"github.com/mathiasbq/hyperguild/ingestion/internal/llm"
	"github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
	"github.com/mathiasbq/hyperguild/ingestion/internal/watcher"
)

func main() {
	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

	brainDir := envOr("INGEST_BRAIN_DIR", "../brain")
	port := envOr("INGEST_PORT", "3300")

	llmClient := llm.New(
		envOr("INGEST_LLM_URL", "http://iguana:4000/v1"),
		os.Getenv("INGEST_LLM_KEY"),
		envOr("INGEST_LLM_MODEL", "koala/qwen35-9b-fast"),
		time.Duration(parseInt(envOr("INGEST_LLM_TIMEOUT", "15")))*time.Minute,
	)

	pc := pipeline.Config{
		Complete:  llmClient.Complete,
		ChunkSize: parseInt(envOr("INGEST_CHUNK_SIZE", "6000")),
	}

	h := api.NewHandler(brainDir, logger, pc)

	mux := http.NewServeMux()
	mux.HandleFunc("/query", h.Query)
	mux.HandleFunc("/write", h.Write)
	mux.HandleFunc("/ingest", h.Ingest)
	mux.HandleFunc("/ingest-path", h.IngestPath)

	watchInterval := parseInt(envOr("INGEST_WATCH_INTERVAL", "30"))
	if watchInterval > 0 {
		w := watcher.New(watcher.Config{
			BrainDir: brainDir,
			Interval: time.Duration(watchInterval) * time.Second,
			Pipeline: pc,
			Logger:   logger,
		})
		go w.Start(context.Background())
		logger.Info("watcher started", "interval_s", watchInterval, "raw_dir", brainDir+"/raw")
	}

	addr := ":" + port
	logger.Info("ingestion server starting", "addr", addr, "brain_dir", brainDir)
	if err := http.ListenAndServe(addr, mux); err != nil {
		logger.Error("server stopped", "err", err)
		os.Exit(1)
	}
}

func envOr(key, def string) string {
	if v := os.Getenv(key); v != "" {
		return v
	}
	return def
}

func parseInt(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}
```

- [ ] **Step 6: Build to verify (watcher package doesn't exist yet — expect one error)**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go build ./... 2>&1
```

Expected: `cannot find package "…/watcher"` — this is fine, Task 11 adds it.

- [ ] **Step 7: Commit what compiles**

```bash
git add ingestion/internal/api/handler.go ingestion/internal/api/handler_test.go \
        ingestion/cmd/server/main.go
git commit -m "feat(ingestion): add /ingest and /ingest-path HTTP handlers"
```

---

## Task 11: watcher — background file processor

**Files:**
- Create: `ingestion/internal/watcher/watcher.go`
- Create: `ingestion/internal/watcher/watcher_test.go`

- [ ] **Step 1: Write the failing test**

```go
// ingestion/internal/watcher/watcher_test.go
package watcher

import (
	"context"
	"os"
	"path/filepath"
	"testing"
	"time"

	"log/slog"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
	"github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
)

func TestWatcher_SuccessfulFileMovedToProcessed(t *testing.T) {
	brainDir := t.TempDir()
	rawDir := filepath.Join(brainDir, "raw")
	require.NoError(t, os.MkdirAll(rawDir, 0o755))
	for _, sub := range []string{"wiki/concepts", "wiki/entities", "wiki/sources"} {
		require.NoError(t, os.MkdirAll(filepath.Join(brainDir, sub), 0o755))
	}

	// Drop a file into raw/.
	rawFile := filepath.Join(rawDir, "test-note.md")
	require.NoError(t, os.WriteFile(rawFile, []byte("test content"), 0o644))

	// Pipeline complete func returns one page.
	successComplete := func(_ context.Context, _, _ string) (string, error) {
		pages := []wiki.Page{{Path: "wiki/sources/test-note.md", Content: "---\ntitle: Test\n---\n"}}
		b, _ := json.Marshal(pages)
		return string(b), nil
	}

	w := New(Config{
		BrainDir: brainDir,
		Interval: 50 * time.Millisecond,
		Pipeline: pipeline.Config{Complete: successComplete},
		Logger:   slog.New(slog.NewTextHandler(os.Stderr, nil)),
	})

	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()
	go w.Start(ctx)
	<-ctx.Done()

	// File must be gone from raw/.
	_, err := os.Stat(rawFile)
	assert.True(t, os.IsNotExist(err), "file should have been moved out of raw/")

	// File must be in processed/.
	entries, err := filepath.Glob(filepath.Join(brainDir, "raw", "processed", "*", "test-note.md"))
	require.NoError(t, err)
	assert.Len(t, entries, 1)
}

func TestWatcher_FailedFileMovedToFailed(t *testing.T) {
	brainDir := t.TempDir()
	rawDir := filepath.Join(brainDir, "raw")
	require.NoError(t, os.MkdirAll(rawDir, 0o755))
	for _, sub := range []string{"wiki/concepts", "wiki/entities", "wiki/sources"} {
		require.NoError(t, os.MkdirAll(filepath.Join(brainDir, sub), 0o755))
	}

	rawFile := filepath.Join(rawDir, "bad-note.md")
	require.NoError(t, os.WriteFile(rawFile, []byte("bad"), 0o644))

	errorComplete := func(_ context.Context, _, _ string) (string, error) {
		return "", fmt.Errorf("LLM unavailable")
	}

	w := New(Config{
		BrainDir: brainDir,
		Interval: 50 * time.Millisecond,
		Pipeline: pipeline.Config{Complete: errorComplete},
		Logger:   slog.New(slog.NewTextHandler(os.Stderr, nil)),
	})

	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	defer cancel()
	go w.Start(ctx)
	<-ctx.Done()

	_, err := os.Stat(rawFile)
	assert.True(t, os.IsNotExist(err))

	_, err = os.Stat(filepath.Join(brainDir, "raw", "failed", "bad-note.md"))
	require.NoError(t, err)
}
```

Add imports to the test file:
```go
import (
    "context"
    "encoding/json"
    "fmt"
    "log/slog"
    "os"
    "path/filepath"
    "testing"
    "time"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"

    "github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
    "github.com/mathiasbq/hyperguild/ingestion/internal/wiki"
)
```

- [ ] **Step 2: Run test to verify it fails**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/watcher/... 2>&1
```

Expected: `undefined: New`

- [ ] **Step 3: Write watcher.go**

```go
// ingestion/internal/watcher/watcher.go
package watcher

import (
	"context"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/mathiasbq/hyperguild/ingestion/internal/pipeline"
)

var supportedExts = map[string]bool{".md": true, ".txt": true, ".pdf": true}

// Config configures the file watcher.
type Config struct {
	BrainDir string
	Interval time.Duration
	Pipeline pipeline.Config
	Logger   *slog.Logger
}

// Watcher polls brain/raw/ and triggers ingestion for new files.
type Watcher struct {
	cfg Config
}

// New constructs a Watcher.
func New(cfg Config) *Watcher { return &Watcher{cfg: cfg} }

// Start polls brain/raw/ at cfg.Interval until ctx is cancelled.
func (w *Watcher) Start(ctx context.Context) {
	ticker := time.NewTicker(w.cfg.Interval)
	defer ticker.Stop()
	for {
		select {
		case <-ctx.Done():
			return
		case <-ticker.C:
			w.poll(ctx)
		}
	}
}

func (w *Watcher) poll(ctx context.Context) {
	rawDir := filepath.Join(w.cfg.BrainDir, "raw")
	entries, err := os.ReadDir(rawDir)
	if err != nil {
		if !os.IsNotExist(err) {
			w.cfg.Logger.Warn("watcher: read raw dir", "err", err)
		}
		return
	}
	for _, e := range entries {
		if e.IsDir() {
			continue
		}
		ext := strings.ToLower(filepath.Ext(e.Name()))
		if !supportedExts[ext] {
			continue
		}
		w.processFile(ctx, filepath.Join(rawDir, e.Name()))
	}
}

func (w *Watcher) processFile(ctx context.Context, path string) {
	content, err := os.ReadFile(path)
	if err != nil {
		w.cfg.Logger.Error("watcher: read file", "path", path, "err", err)
		return
	}

	source := sourceFromFilename(filepath.Base(path))
	_, err = pipeline.Run(ctx, w.cfg.Pipeline, w.cfg.BrainDir, string(content), source, false)
	if err != nil {
		w.cfg.Logger.Error("watcher: ingest failed", "path", path, "err", err)
		w.moveFile(path, filepath.Join(w.cfg.BrainDir, "raw", "failed"))
		return
	}

	date := time.Now().UTC().Format("2006-01-02")
	w.moveFile(path, filepath.Join(w.cfg.BrainDir, "raw", "processed", date))
}

func (w *Watcher) moveFile(src, destDir string) {
	if err := os.MkdirAll(destDir, 0o755); err != nil {
		w.cfg.Logger.Error("watcher: mkdir", "dir", destDir, "err", err)
		return
	}
	dest := filepath.Join(destDir, filepath.Base(src))
	if err := os.Rename(src, dest); err != nil {
		w.cfg.Logger.Error("watcher: move file", "src", src, "dest", dest, "err", err)
	}
}

func sourceFromFilename(filename string) string {
	name := strings.TrimSuffix(filename, filepath.Ext(filename))
	words := strings.FieldsFunc(name, func(r rune) bool { return r == '-' || r == '_' })
	for i, word := range words {
		if len(word) > 0 {
			words[i] = strings.ToUpper(word[:1]) + word[1:]
		}
	}
	return strings.Join(words, " ")
}
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go test ./internal/watcher/... -v
```

Expected: all PASS.

- [ ] **Step 5: Full build and test**

```bash
cd /Users/mathias/dev/AI/hyperguild/ingestion && go build ./... && go test ./... 2>&1
```

Expected: clean build, all tests PASS.

- [ ] **Step 6: Commit**

```bash
git add ingestion/internal/watcher/
git commit -m "feat(ingestion): add background file watcher for brain/raw/"
```

- [ ] **Step 7: Final supervisor build check**

```bash
cd /Users/mathias/dev/AI/hyperguild && go build ./...
```

Expected: no output (clean build).

- [ ] **Step 8: Final commit**

```bash
git add ingestion/cmd/server/main.go
git commit -m "feat(ingestion): wire watcher and new env vars in server main"
```

---

## Self-Review Checklist

**Spec coverage:**
- [x] `/ingest` endpoint → Task 10
- [x] `/ingest-path` endpoint (file + directory) → Task 10
- [x] File watcher on `brain/raw/` → Task 11
- [x] Success → `processed/YYYY-MM-DD/`, failure → `failed/` → Task 11
- [x] LLM client with retry-on-429 — **GAP**: the client handles non-200 errors but the spec says "retry on 429". Add retry to `llm/client.go` in Task 7 Step 3.
- [x] Pipeline: inventory → schema → chunk → LLM → parse → merge → write → index → log → Task 9
- [x] Truncation recovery → Task 8
- [x] `brain/CLAUDE.md` embedded fallback → Task 9 (`defaultSchema` constant)
- [x] Supervisor config wiring → Task 1
- [x] `brain_ingest` optional `path` field — **GAP**: `internal/skills/brain/handlers.go` already has `brain_ingest` calling `/ingest`. The spec says `brain_ingest` should gain a `path` field to call `/ingest-path` instead.

**Fixing gaps:**

For the 429 retry, add to `llm/client.go` after the `httpClient.Do` call in `Complete`:

```go
// Retry once on 429 with Retry-After header or 5s backoff.
if resp.StatusCode == http.StatusTooManyRequests {
    resp.Body.Close()
    wait := 5 * time.Second
    if ra := resp.Header.Get("Retry-After"); ra != "" {
        if secs, err := strconv.Atoi(ra); err == nil {
            wait = time.Duration(secs) * time.Second
        }
    }
    select {
    case <-ctx.Done():
        return "", ctx.Err()
    case <-time.After(wait):
    }
    resp, err = c.httpClient.Do(req.Clone(ctx))
    if err != nil {
        return "", fmt.Errorf("retry LLM call: %w", err)
    }
    defer resp.Body.Close()
    out, err = io.ReadAll(resp.Body)
    if err != nil {
        return "", fmt.Errorf("read retry response: %w", err)
    }
}
```

Add `"strconv"` to imports in `client.go`. Note: `req.Clone(ctx)` resets the body reader — since we used `bytes.NewReader`, build the request inside a helper or reconstruct it. Simplest fix: extract request building into a closure. This is handled inline in Task 7 Step 3 — plan readers should add this block after the initial `httpClient.Do`.

For the `brain_ingest` `path` field, add to `internal/skills/brain/handlers.go` in the existing `ingestArgs` struct:

```go
type ingestArgs struct {
    Content string `json:"content"`
    Source  string `json:"source"`
    Path    string `json:"path,omitempty"`   // ← add this
    DryRun  bool   `json:"dry_run,omitempty"`
}
```

And in the `ingest` method, choose the endpoint based on whether `Path` is set:

```go
func (s *Skill) ingest(ctx context.Context, args json.RawMessage) (json.RawMessage, error) {
    var a ingestArgs
    if err := json.Unmarshal(args, &a); err != nil {
        return nil, fmt.Errorf("parse args: %w", err)
    }
    if a.Path == "" && a.Content == "" {
        return nil, fmt.Errorf("content or path is required")
    }
    if a.Source == "" && a.Path == "" {
        return nil, fmt.Errorf("source is required when content is provided")
    }
    if s.cfg.IngestSvcURL == "" {
        return nil, fmt.Errorf("brain_ingest: INGEST_SVC_URL not configured")
    }
    if a.Path != "" {
        return s.postTo(ctx, s.cfg.IngestSvcURL+"/ingest-path", a)
    }
    return s.postTo(ctx, s.cfg.IngestSvcURL+"/ingest", a)
}
```

Also update the `brain_ingest` tool description in `skill.go` to mention the `path` field:

```go
InputSchema: schema([]string{}, map[string]any{
    "content": str,
    "path":    map[string]any{"type": "string", "description": "file or directory path to ingest (alternative to content)"},
    "source":  map[string]any{"type": "string", "description": "human-readable source name, e.g. 'shape-up-book'"},
    "dry_run": map[string]any{"type": "boolean"},
}),
```

These two fixes should be incorporated into Task 7 and after Task 11 respectively, or applied as a final cleanup commit.