Incremental Re-ingest + Phase 0 Capture (tatara-memory-repo-ingester) Implementation Plan¶

func TestEdgeConfidenceFields(t *testing.T) {
    e := contract.Edge{
        From: "a", To: "b", Relation: contract.RelCalls, SrcFile: "x.go",
        ConfidenceScore: 0.98, ConfidenceTier: contract.TierInferred,
        Properties: map[string]string{"resolution": contract.ResTypeResolved},
    }
    b, err := json.Marshal(e)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    require.ElementsMatch(t,
        []string{"from", "to", "relation", "src_file", "confidence_score", "confidence_tier", "properties"},
        keys(got))
    require.InDelta(t, 0.98, got["confidence_score"], 1e-9)
    require.Equal(t, "INFERRED", got["confidence_tier"])
}

func TestEdgeConfidenceOmitEmpty(t *testing.T) {
    e := contract.Edge{From: "a", To: "b", Relation: contract.RelCalls, SrcFile: "x.go"}
    b, err := json.Marshal(e)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    _, hasScore := got["confidence_score"]
    _, hasTier := got["confidence_tier"]
    require.False(t, hasScore, "confidence_score must be absent when zero")
    require.False(t, hasTier, "confidence_tier must be absent when empty")
}

func TestTierForScore(t *testing.T) {
    cases := []struct {
        name  string
        score float64
        tier  string
    }{
        {"extracted", 1.0, contract.TierExtracted},
        {"inferred_high", 0.98, contract.TierInferred},
        {"inferred_mid", 0.45, contract.TierInferred},
        {"ambiguous_boundary", 0.3, contract.TierAmbiguous},
        {"ambiguous_low", 0.0, contract.TierAmbiguous},
    }
    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            require.Equal(t, tc.tier, contract.TierForScore(tc.score))
        })
    }
}

// Edge is a directed, typed relationship between two entities.
type Edge struct {
    From            string            `json:"from"`
    To              string            `json:"to"`
    Relation        string            `json:"relation"`
    SrcFile         string            `json:"src_file"`
    ConfidenceScore float64           `json:"confidence_score,omitempty"` // 1.0 EXTRACTED, <1 INFERRED
    ConfidenceTier  string            `json:"confidence_tier,omitempty"`  // EXTRACTED|INFERRED|AMBIGUOUS
    Properties      map[string]string `json:"properties,omitempty"`
}

// Confidence tier values (typed column on code_edges; promoted from the scalar score).
const (
    TierExtracted = "EXTRACTED"
    TierInferred  = "INFERRED"
    TierAmbiguous = "AMBIGUOUS"
)

// TierForScore maps a confidence score to a tier:
// 1.0 -> EXTRACTED; (0.3,1.0) -> INFERRED; <=0.3 -> AMBIGUOUS.
func TierForScore(score float64) string {
    switch {
    case score >= 1.0:
        return TierExtracted
    case score > 0.3:
        return TierInferred
    default:
        return TierAmbiguous
    }
}

func TestEntityProvenanceFields(t *testing.T) {
    e := contract.Entity{
        ID: "doc:file:README.md", Name: "README.md", Type: contract.EntityDocFile,
        FilePath: "README.md", LineStart: 1, LineEnd: 42,
        SourceURL: "https://example.com/x", Author: "alice", CapturedAt: "2026-06-09T00:00:00Z",
    }
    b, err := json.Marshal(e)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    require.ElementsMatch(t,
        []string{"id", "name", "type", "file_path", "line_start", "line_end", "source_url", "author", "captured_at"},
        keys(got))
}

func TestEntityProvenanceOmitEmpty(t *testing.T) {
    e := contract.Entity{ID: "go:package:m", Name: "m", Type: contract.EntityGoPackage, FilePath: ""}
    b, err := json.Marshal(e)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    for _, k := range []string{"line_start", "line_end", "source_url", "author", "captured_at"} {
        _, has := got[k]
        require.False(t, has, "%s must be absent when empty", k)
    }
}

func TestDocEntityTypeConstants(t *testing.T) {
    require.Equal(t, "doc_file", contract.EntityDocFile)
    require.Equal(t, "doc_section", contract.EntityDocSection)
    require.Equal(t, "concept", contract.EntityConcept)
    require.Equal(t, "rationale", contract.EntityRationale)
}

// Entity is a node in the code graph.
type Entity struct {
    ID          string            `json:"id"`
    Name        string            `json:"name"`
    Type        string            `json:"type"`
    Description string            `json:"description,omitempty"`
    FilePath    string            `json:"file_path"`
    LineStart   int               `json:"line_start,omitempty"`  // Go already computes these
    LineEnd     int               `json:"line_end,omitempty"`    //
    SourceURL   string            `json:"source_url,omitempty"`  // doc frontmatter
    Author      string            `json:"author,omitempty"`      // doc frontmatter
    CapturedAt  string            `json:"captured_at,omitempty"` // doc frontmatter, RFC3339
    Properties  map[string]string `json:"properties,omitempty"`
}

    EntityHelmValue    = "helm_value"
    EntityDocFile      = "doc_file"
    EntityDocSection   = "doc_section"
    EntityConcept      = "concept"
    EntityRationale    = "rationale"
)

func TestHyperedgeJSONShape(t *testing.T) {
    h := contract.Hyperedge{
        ID: "he:1", Label: "trait impl", Relation: "implement",
        ConfidenceScore: 0.9, SrcFile: "x.go",
        Members:    []string{"go:type:m.A", "go:type:m.B", "go:type:m.C"},
        Properties: map[string]string{"k": "v"},
    }
    b, err := json.Marshal(h)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    require.ElementsMatch(t,
        []string{"id", "label", "relation", "confidence_score", "src_file", "members", "properties"},
        keys(got))
    require.Len(t, got["members"].([]any), 3)
}

func TestGraphPushHyperedgesOmitEmpty(t *testing.T) {
    p := contract.GraphPush{Repo: "r", Files: []string{"a.go"}, Entities: []contract.Entity{}, Edges: []contract.Edge{}}
    b, err := json.Marshal(p)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    _, has := got["hyperedges"]
    require.False(t, has, "hyperedges key must be absent when empty")
}

func TestGraphPushHyperedgesPresentWhenSet(t *testing.T) {
    p := contract.GraphPush{
        Repo: "r", Files: []string{"a.go"}, Entities: []contract.Entity{}, Edges: []contract.Edge{},
        Hyperedges: []contract.Hyperedge{{ID: "he:1", Label: "l", Relation: "form", SrcFile: "a.go",
            Members: []string{"x", "y", "z"}}},
    }
    b, err := json.Marshal(p)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    require.Len(t, got["hyperedges"].([]any), 1)
}

func TestSemanticRelationConstants(t *testing.T) {
    require.Equal(t, "conceptually_related_to", contract.RelConceptuallyRelated)
    require.Equal(t, "semantically_similar_to", contract.RelSemanticallySimilar)
    require.Equal(t, "rationale_for", contract.RelRationaleFor)
    require.Equal(t, "shares_data_with", contract.RelSharesDataWith)
    require.Equal(t, "cites", contract.RelCites)
}

// Hyperedge is an n-ary relationship over 3+ entities (Phase 2 producer; reserved now).
type Hyperedge struct {
    ID              string            `json:"id"`
    Label           string            `json:"label"`
    Relation        string            `json:"relation"` // participate_in|implement|form
    ConfidenceScore float64           `json:"confidence_score,omitempty"`
    SrcFile         string            `json:"src_file"`
    Members         []string          `json:"members"` // entity IDs (3+)
    Properties      map[string]string `json:"properties,omitempty"`
}

// GraphPush is one /code-graph:bulk request.
type GraphPush struct {
    Repo       string      `json:"repo"`
    Commit     string      `json:"commit,omitempty"`
    Files      []string    `json:"files"`
    Entities   []Entity    `json:"entities"`
    Edges      []Edge      `json:"edges"`
    Symbols    []SymbolRow `json:"symbols,omitempty"`
    Hyperedges []Hyperedge `json:"hyperedges,omitempty"` // empty until Phase 2
}

    RelSubchart     = "subchart"

    // Semantic relations (reserved Phase 0, emitted Phase 2).
    RelConceptuallyRelated = "conceptually_related_to"
    RelSemanticallySimilar = "semantically_similar_to"
    RelRationaleFor        = "rationale_for"
    RelSharesDataWith      = "shares_data_with"
    RelCites               = "cites"
)

func TestBulkMemoriesRequestShape(t *testing.T) {
    req := contract.BulkMemoriesRequest{
        ReconcileFiles: []string{"a.go", "b.md"},
        Items:          []contract.IngestItem{{IdempotencyKey: "k", Text: "t"}},
    }
    b, err := json.Marshal(req)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    require.ElementsMatch(t, []string{"reconcile_files", "items"}, keys(got))
    require.Len(t, got["reconcile_files"].([]any), 2)
}

func TestBulkMemoriesRequestReconcileOmitEmpty(t *testing.T) {
    req := contract.BulkMemoriesRequest{Items: []contract.IngestItem{{IdempotencyKey: "k", Text: "t"}}}
    b, err := json.Marshal(req)
    require.NoError(t, err)
    var got map[string]any
    require.NoError(t, json.Unmarshal(b, &got))
    _, has := got["reconcile_files"]
    require.False(t, has, "reconcile_files must be absent when empty")
    require.ElementsMatch(t, []string{"items"}, keys(got))
}

// BulkMemoriesRequest is the /memories:bulk request body. ReconcileFiles, when
// set, instructs the server to purge prior memories for each file (by source)
// before inserting Items. Absent ReconcileFiles preserves insert-only behavior.
type BulkMemoriesRequest struct {
    ReconcileFiles []string     `json:"reconcile_files,omitempty"`
    Items          []IngestItem `json:"items"`
}

package walk_test

import (
    "crypto/sha256"
    "encoding/hex"
    "os"
    "os/exec"
    "path/filepath"
    "testing"

    "github.com/stretchr/testify/require"

    "github.com/szymonrychu/tatara-memory-repo-ingester/internal/walk"
)

func gitRepo(t *testing.T) string {
    t.Helper()
    dir := t.TempDir()
    for _, args := range [][]string{
        {"init", "-q"}, {"config", "user.email", "t@t"}, {"config", "user.name", "t"},
    } {
        cmd := exec.Command("git", args...)
        cmd.Dir = dir
        require.NoError(t, cmd.Run())
    }
    return dir
}

func write(t *testing.T, dir, rel, content string) {
    t.Helper()
    p := filepath.Join(dir, rel)
    require.NoError(t, os.MkdirAll(filepath.Dir(p), 0o755))
    require.NoError(t, os.WriteFile(p, []byte(content), 0o644))
}

func commit(t *testing.T, dir, msg string) string {
    t.Helper()
    for _, args := range [][]string{{"add", "-A"}, {"commit", "-q", "-m", msg}} {
        cmd := exec.Command("git", args...)
        cmd.Dir = dir
        require.NoError(t, cmd.Run())
    }
    out, err := exec.Command("git", "-C", dir, "rev-parse", "HEAD").Output()
    require.NoError(t, err)
    return string(out[:len(out)-1])
}

func sha(content string) string {
    sum := sha256.Sum256([]byte(content))
    return hex.EncodeToString(sum[:])
}

// byPath indexes a Changes result by new path for assertions.
func byPath(c walk.Changes) map[string]walk.Change {
    m := map[string]walk.Change{}
    for _, ch := range c.Files {
        m[ch.Path] = ch
    }
    return m
}

func TestFullWalkListsTrackedFiles(t *testing.T) {
    dir := gitRepo(t)
    write(t, dir, "a.go", "package a")
    write(t, dir, "sub/b.py", "x = 1")
    commit(t, dir, "init")

    got, err := walk.Diff(dir, "", false)
    require.NoError(t, err)
    require.True(t, got.FullSet)
    m := byPath(got)
    require.Len(t, m, 2)
    require.Equal(t, 'A', m["a.go"].Status)
    require.Equal(t, 'A', m["sub/b.py"].Status)
    require.Equal(t, sha("package a"), m["a.go"].ContentSHA)
}

func TestFullFlagOverridesSince(t *testing.T) {
    dir := gitRepo(t)
    write(t, dir, "a.go", "package a")
    base := commit(t, dir, "init")
    write(t, dir, "c.go", "package c")
    commit(t, dir, "add c")

    got, err := walk.Diff(dir, base, true)
    require.NoError(t, err)
    require.True(t, got.FullSet)
    m := byPath(got)
    require.Len(t, m, 2)
    require.Contains(t, m, "a.go")
    require.Contains(t, m, "c.go")
}

// Package walk lists the repository files to ingest.
package walk

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "log/slog"
    "os"
    "os/exec"
    "path/filepath"
    "sort"
    "strings"
)

// Change is one touched file classified by git status.
type Change struct {
    Path       string // new path (for renames, the destination)
    OldPath    string // populated only for renames
    Status     rune   // 'A' added, 'M' modified, 'D' deleted, 'R' renamed
    ContentSHA string // sha256 of working-tree content for A/M; empty for D
}

// Changes is the classified diff result.
type Changes struct {
    Files   []Change // every touched file
    FullSet bool     // true when produced by ls-files (first/full/fallback)
}

// Diff classifies the files to ingest. With full or empty since, it lists all
// tracked files as additions (FullSet). Otherwise it runs
// `git diff --name-status <since>..HEAD`; if that command fails (since not an
// ancestor: force-push, rebase, GC'd commit) it logs WARN and falls back to the
// full ls-files path so a job never hard-fails on history rewrite.
func Diff(repoRoot, since string, full bool) (Changes, error) {
    if full || since == "" {
        return fullSet(repoRoot)
    }
    out, err := exec.Command("git", "-C", repoRoot, "diff", "--name-status", since+"..HEAD").Output() //nolint:gosec
    if err != nil {
        slog.Warn("git diff failed; falling back to full ls-files",
            "since", since, "error", err)
        return fullSet(repoRoot)
    }
    return parseDiff(repoRoot, string(out))
}

// fullSet lists all tracked files as additions.
func fullSet(repoRoot string) (Changes, error) {
    out, err := exec.Command("git", "-C", repoRoot, "ls-files").Output() //nolint:gosec
    if err != nil {
        return Changes{}, fmt.Errorf("git -C %s ls-files: %w", repoRoot, err)
    }
    var files []Change
    for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
        if line == "" {
            continue
        }
        files = append(files, Change{Path: line, Status: 'A', ContentSHA: contentSHA(repoRoot, line)})
    }
    sortChanges(files)
    return Changes{Files: files, FullSet: true}, nil
}

// parseDiff turns `git diff --name-status` output into classified changes.
// Rename lines `R<score>\told\tnew` become a single Change with Status 'R',
// OldPath=old, Path=new. Copy lines `C<score>` are treated as additions of new.
func parseDiff(repoRoot, out string) (Changes, error) {
    var files []Change
    for _, line := range strings.Split(strings.TrimSpace(out), "\n") {
        if line == "" {
            continue
        }
        fields := strings.Split(line, "\t")
        code := fields[0]
        switch code[0] {
        case 'A', 'M':
            if len(fields) < 2 {
                continue
            }
            p := fields[1]
            files = append(files, Change{Path: p, Status: rune(code[0]), ContentSHA: contentSHA(repoRoot, p)})
        case 'D':
            if len(fields) < 2 {
                continue
            }
            files = append(files, Change{Path: fields[1], Status: 'D'})
        case 'R':
            if len(fields) < 3 {
                continue
            }
            files = append(files, Change{
                Path: fields[2], OldPath: fields[1], Status: 'R',
                ContentSHA: contentSHA(repoRoot, fields[2]),
            })
        case 'C':
            if len(fields) < 3 {
                continue
            }
            p := fields[2]
            files = append(files, Change{Path: p, Status: 'A', ContentSHA: contentSHA(repoRoot, p)})
        }
    }
    sortChanges(files)
    return Changes{Files: files, FullSet: false}, nil
}

// contentSHA returns the sha256 hex of the working-tree file; empty when unreadable.
func contentSHA(repoRoot, rel string) string {
    b, err := os.ReadFile(filepath.Join(repoRoot, rel)) //nolint:gosec
    if err != nil {
        return ""
    }
    sum := sha256.Sum256(b)
    return hex.EncodeToString(sum[:])
}

// sortChanges orders by new path for deterministic output.
func sortChanges(files []Change) {
    sort.Slice(files, func(i, j int) bool { return files[i].Path < files[j].Path })
}

func TestSinceDiffClassifiesAddModifyDelete(t *testing.T) {
    dir := gitRepo(t)
    write(t, dir, "keep.go", "package a")
    write(t, dir, "gone.go", "package g")
    base := commit(t, dir, "init")

    write(t, dir, "keep.go", "package a // changed")
    write(t, dir, "new.go", "package n")
    require.NoError(t, os.Remove(filepath.Join(dir, "gone.go")))
    commit(t, dir, "mutate")

    got, err := walk.Diff(dir, base, false)
    require.NoError(t, err)
    require.False(t, got.FullSet)
    m := byPath(got)
    require.Equal(t, 'M', m["keep.go"].Status)
    require.Equal(t, sha("package a // changed"), m["keep.go"].ContentSHA)
    require.Equal(t, 'A', m["new.go"].Status)
    require.Equal(t, sha("package n"), m["new.go"].ContentSHA)
    require.Equal(t, 'D', m["gone.go"].Status)
    require.Empty(t, m["gone.go"].ContentSHA, "deleted file has no content sha")
}

func TestSinceDiffPairsRename(t *testing.T) {
    dir := gitRepo(t)
    write(t, dir, "old/name.go", "package x\n\nfunc Stable() {}\n")
    base := commit(t, dir, "init")

    require.NoError(t, os.MkdirAll(filepath.Join(dir, "new"), 0o755))
    require.NoError(t, os.Rename(
        filepath.Join(dir, "old/name.go"), filepath.Join(dir, "new/name.go")))
    commit(t, dir, "rename")

    got, err := walk.Diff(dir, base, false)
    require.NoError(t, err)
    require.False(t, got.FullSet)
    require.Len(t, got.Files, 1)
    ch := got.Files[0]
    require.Equal(t, 'R', ch.Status)
    require.Equal(t, "new/name.go", ch.Path)
    require.Equal(t, "old/name.go", ch.OldPath)
    require.Equal(t, sha("package x\n\nfunc Stable() {}\n"), ch.ContentSHA)
}

func TestMissingSinceFallsBackToFull(t *testing.T) {
    dir := gitRepo(t)
    write(t, dir, "a.go", "package a")
    write(t, dir, "b.go", "package b")
    commit(t, dir, "init")

    // A since SHA that does not exist in this repo: diff must error and fall back.
    got, err := walk.Diff(dir, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", false)
    require.NoError(t, err, "missing since must not hard-fail")
    require.True(t, got.FullSet, "fallback uses ls-files full set")
    m := byPath(got)
    require.Len(t, m, 2)
    require.Equal(t, 'A', m["a.go"].Status)
    require.Equal(t, 'A', m["b.go"].Status)
}

func TestRunSendsDeletedFilesInGraphAndReconcile(t *testing.T) {
    dir := t.TempDir()
    for _, a := range [][]string{{"init", "-q"}, {"config", "user.email", "t@t"}, {"config", "user.name", "t"}} {
        c := exec.Command("git", a...)
        c.Dir = dir
        require.NoError(t, c.Run())
    }
    require.NoError(t, os.WriteFile(filepath.Join(dir, "keep.go"),
        []byte("package m\n\nfunc Keep() {}\n"), 0o644))
    require.NoError(t, os.WriteFile(filepath.Join(dir, "gone.go"),
        []byte("package m\n\nfunc Gone() {}\n"), 0o644))
    require.NoError(t, os.WriteFile(filepath.Join(dir, "go.mod"),
        []byte("module example.com/m\n\ngo 1.25\n"), 0o644))
    base := commitAll(t, dir, "init")

    require.NoError(t, os.Remove(filepath.Join(dir, "gone.go")))
    require.NoError(t, os.WriteFile(filepath.Join(dir, "keep.go"),
        []byte("package m\n\nfunc Keep() { _ = 1 }\n"), 0o644))
    commitAll(t, dir, "delete gone, modify keep")

    var capturedPush contract.GraphPush
    srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        switch r.URL.Path {
        case "/code-graph:bulk":
            body, _ := io.ReadAll(r.Body)
            _ = json.Unmarshal(body, &capturedPush)
            w.WriteHeader(200)
            _, _ = w.Write([]byte(`{"repo":"m"}`))
        case "/memories:bulk":
            w.WriteHeader(202)
            _, _ = w.Write([]byte(`{"id":"j","status":"succeeded"}`))
        default:
            _, _ = w.Write([]byte(`{"id":"j","status":"succeeded"}`))
        }
    }))
    defer srv.Close()

    opts := options{repoRoot: dir, repoName: "m", baseURL: srv.URL, since: base}
    require.NoError(t, run(context.Background(), opts, http.DefaultClient))

    require.Contains(t, capturedPush.Files, "gone.go", "deleted file must be in code-graph Files")
    require.Contains(t, capturedPush.Files, "keep.go", "modified file must be in code-graph Files")
    for _, e := range capturedPush.Entities {
        require.NotEqual(t, "gone.go", e.FilePath, "deleted file must contribute no entities")
    }
}

// commitAll commits all changes and returns HEAD.
func commitAll(t *testing.T, dir, msg string) string {
    t.Helper()
    for _, a := range [][]string{{"add", "-A"}, {"commit", "-q", "-m", msg}} {
        c := exec.Command("git", a...)
        c.Dir = dir
        require.NoError(t, c.Run())
    }
    out, err := exec.Command("git", "-C", dir, "rev-parse", "HEAD").Output()
    require.NoError(t, err)
    return strings.TrimSpace(string(out))
}

func run(ctx context.Context, o options, hc *http.Client) error {
    if o.scipPath != "" {
        return runSCIP(ctx, o, hc)
    }
    start := time.Now()
    changes, err := walk.Diff(o.repoRoot, o.since, o.full)
    if err != nil {
        return err
    }

    // touched is every file in the diff (code-graph Files + memories reconcile_files).
    // analyzeFiles is only A/M/renamed-new (the files we re-analyze and chunk).
    var touched, analyzeFiles []string
    for _, ch := range changes.Files {
        touched = append(touched, ch.Path)
        switch ch.Status {
        case 'A', 'M', 'R':
            analyzeFiles = append(analyzeFiles, ch.Path)
        }
    }

    reg := analyze.Default(o.crossRepoPrefix)
    groups := reg.Group(analyzeFiles)

    var agg analyze.Result
    for _, a := range reg.Analyzers() {
        fs := groups[a.Name()]
        if len(fs) == 0 {
            continue
        }
        res, err := a.Analyze(ctx, o.repoRoot, fs)
        if err != nil {
            slog.Warn("analyzer failed", "analyzer", a.Name(), "error", err)
            continue
        }
        agg.Entities = append(agg.Entities, res.Entities...)
        agg.Edges = append(agg.Edges, res.Edges...)
        agg.Chunks = append(agg.Chunks, res.Chunks...)
        agg.Symbols = append(agg.Symbols, res.Symbols...)
    }

    commit := headCommit(o.repoRoot)
    cl := push.New(o.baseURL, hc, pollOr(o.pollInterval))
    if _, err := cl.PushGraph(ctx, contract.GraphPush{
        Repo: o.repoName, Commit: commit, Files: touched,
        Entities: agg.Entities, Edges: agg.Edges, Symbols: agg.Symbols,
        Hyperedges: agg.Hyperedges,
    }); err != nil {
        return err
    }
    reconcile := touched
    if changes.FullSet {
        reconcile = nil // first/full ingest is insert-only (no reconcile)
    }
    if err := cl.PushChunks(ctx, reconcile, push.ItemsFromChunks(o.repoName, agg.Chunks)); err != nil {
        return err
    }
    slog.Info("ingest complete",
        "repo", o.repoName, "files", len(touched),
        "analyzed", len(analyzeFiles),
        "entities", len(agg.Entities), "edges", len(agg.Edges),
        "chunks", len(agg.Chunks), "symbols", len(agg.Symbols),
        "full", changes.FullSet,
        "duration_ms", time.Since(start).Milliseconds())
    return nil
}