feat: add unannotated symbol detection to lint command

ccg lint now also reports functions, classes, and types that have no
annotations. Test nodes are excluded since they don't need annotations.

Example output:
  Unannotated symbols (3) — no @intent or other annotations:
    internal/auth/login.go::Login
    internal/payment/pay.go::Pay
    pkg/service.go::Config

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: tae2089

internal/cli/lint.go

@@ -39,7 +39,7 @@ func newLintCmd(deps *Deps) *cobra.Command {
 			}
 
 			out := stdout(cmd)
-			total := len(report.Orphans) + len(report.Missing) + len(report.Stale)
+			total := len(report.Orphans) + len(report.Missing) + len(report.Stale) + len(report.Unannotated)
 
 			if len(report.Orphans) > 0 {
 				fmt.Fprintf(out, "Orphan docs (%d) — no matching source in graph:\n", len(report.Orphans))
@@ -65,11 +65,19 @@ func newLintCmd(deps *Deps) *cobra.Command {
 				fmt.Fprintln(out)
 			}
 
+			if len(report.Unannotated) > 0 {
+				fmt.Fprintf(out, "Unannotated symbols (%d) — no @intent or other annotations:\n", len(report.Unannotated))
+				for _, qn := range report.Unannotated {
+					fmt.Fprintf(out, "  %s\n", qn)
+				}
+				fmt.Fprintln(out)
+			}
+
 			if total == 0 {
 				fmt.Fprintln(out, "All docs are clean — 0 issues found.")
 			} else {
-				fmt.Fprintf(out, "Summary: %d orphan, %d missing, %d stale\n",
-					len(report.Orphans), len(report.Missing), len(report.Stale))
+				fmt.Fprintf(out, "Summary: %d orphan, %d missing, %d stale, %d unannotated\n",
+					len(report.Orphans), len(report.Missing), len(report.Stale), len(report.Unannotated))
 			}
 
 			return nil

internal/cli/lint_test.go

@@ -110,13 +110,18 @@ func TestLintCommand_ReportsStale(t *testing.T) {
 func TestLintCommand_CleanReport(t *testing.T) {
 	deps, stdout, stderr, db := setupLintTest(t)
 
-	db.Create(&model.Node{
+	fn := model.Node{
 		QualifiedName: "pkg/ok.go::Fn",
 		Kind:          model.NodeKindFunction,
 		Name:          "Fn",
 		FilePath:      "pkg/ok.go",
 		StartLine:     1, EndLine: 5,
 		Hash: "h1", Language: "go",
+	}
+	db.Create(&fn)
+	db.Create(&model.Annotation{
+		NodeID: fn.ID,
+		Tags:   []model.DocTag{{Kind: model.TagIntent, Value: "does something", Ordinal: 0}},
 	})
 
 	// Generate docs so everything is fresh
@@ -135,3 +140,29 @@ func TestLintCommand_CleanReport(t *testing.T) {
 		t.Errorf("expected clean report, got:\n%s", out)
 	}
 }
+
+func TestLintCommand_ReportsUnannotated(t *testing.T) {
+	deps, stdout, stderr, db := setupLintTest(t)
+
+	db.Create(&model.Node{
+		QualifiedName: "pkg/svc.go::Handle",
+		Kind:          model.NodeKindFunction,
+		Name:          "Handle",
+		FilePath:      "pkg/svc.go",
+		StartLine:     1, EndLine: 10,
+		Hash: "h1", Language: "go",
+	})
+
+	outDir := t.TempDir()
+	if err := executeCmd(deps, stdout, stderr, "lint", "--out", outDir); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	out := stdout.String()
+	if !strings.Contains(out, "pkg/svc.go::Handle") {
+		t.Errorf("expected unannotated 'pkg/svc.go::Handle' in output, got:\n%s", out)
+	}
+	if !strings.Contains(out, "unannotated") || !strings.Contains(out, "Unannotated") {
+		t.Errorf("expected 'unannotated' label in output, got:\n%s", out)
+	}
+}

internal/docs/lint.go

@@ -13,9 +13,10 @@ import (
 
 // LintReport contains the results of a documentation lint check.
 type LintReport struct {
-	Orphans []string // doc files with no matching source in the graph
-	Missing []string // source files in the graph with no doc file
-	Stale   []string // doc files older than the source's last update
+	Orphans     []string // doc files with no matching source in the graph
+	Missing     []string // source files in the graph with no doc file
+	Stale       []string // doc files older than the source's last update
+	Unannotated []string // qualified names of symbols with no annotation
 }
 
 // Lint checks the documentation directory against the code graph and
@@ -103,9 +104,47 @@ func (g *Generator) Lint() (*LintReport, error) {
 		}
 	}
 
+	// 4. Find unannotated symbols (functions, classes, types — skip tests).
+	var symbolNodes []model.Node
+	if err := g.DB.Select("id, qualified_name, kind, file_path").
+		Where("kind IN ?", []string{
+			string(model.NodeKindFunction),
+			string(model.NodeKindClass),
+			string(model.NodeKindType),
+		}).Find(&symbolNodes).Error; err != nil {
+		return nil, fmt.Errorf("query symbol nodes: %w", err)
+	}
+
+	// Collect IDs to batch-query annotations.
+	ids := make([]uint, 0, len(symbolNodes))
+	nodeByID := map[uint]*model.Node{}
+	for i := range symbolNodes {
+		n := &symbolNodes[i]
+		if len(g.Exclude) > 0 && pathutil.MatchExcludes(g.Exclude, n.FilePath) {
+			continue
+		}
+		ids = append(ids, n.ID)
+		nodeByID[n.ID] = n
+	}
+
+	if len(ids) > 0 {
+		var annotations []model.Annotation
+		g.DB.Select("node_id").Where("node_id IN ?", ids).Find(&annotations)
+		annotated := map[uint]bool{}
+		for _, a := range annotations {
+			annotated[a.NodeID] = true
+		}
+		for _, id := range ids {
+			if !annotated[id] {
+				report.Unannotated = append(report.Unannotated, nodeByID[id].QualifiedName)
+			}
+		}
+	}
+
 	sort.Strings(report.Orphans)
 	sort.Strings(report.Missing)
 	sort.Strings(report.Stale)
+	sort.Strings(report.Unannotated)
 
 	return report, nil
 }

internal/docs/lint_test.go

@@ -164,3 +164,85 @@ func TestLint_EmptyDB_EmptyDir(t *testing.T) {
 			len(report.Orphans), len(report.Missing), len(report.Stale))
 	}
 }
+
+func TestLint_DetectsUnannotated(t *testing.T) {
+	db := newLintTestDB(t)
+	outDir := t.TempDir()
+
+	// Function WITH annotation
+	annotated := model.Node{
+		QualifiedName: "pkg/a.go::Annotated",
+		Kind:          model.NodeKindFunction,
+		Name:          "Annotated",
+		FilePath:      "pkg/a.go",
+		StartLine:     1, EndLine: 10,
+		Hash: "h1", Language: "go",
+	}
+	db.Create(&annotated)
+	db.Create(&model.Annotation{
+		NodeID: annotated.ID,
+		Tags:   []model.DocTag{{Kind: model.TagIntent, Value: "does something", Ordinal: 0}},
+	})
+
+	// Function WITHOUT annotation
+	db.Create(&model.Node{
+		QualifiedName: "pkg/b.go::Bare",
+		Kind:          model.NodeKindFunction,
+		Name:          "Bare",
+		FilePath:      "pkg/b.go",
+		StartLine:     1, EndLine: 10,
+		Hash: "h2", Language: "go",
+	})
+
+	// Type WITHOUT annotation
+	db.Create(&model.Node{
+		QualifiedName: "pkg/b.go::Config",
+		Kind:          model.NodeKindType,
+		Name:          "Config",
+		FilePath:      "pkg/b.go",
+		StartLine:     12, EndLine: 20,
+		Hash: "h3", Language: "go",
+	})
+
+	gen := &Generator{DB: db, OutDir: outDir}
+	report, err := gen.Lint()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(report.Unannotated) != 2 {
+		t.Fatalf("expected 2 unannotated, got %d: %v", len(report.Unannotated), report.Unannotated)
+	}
+
+	// Should NOT include the annotated function
+	for _, u := range report.Unannotated {
+		if u == "pkg/a.go::Annotated" {
+			t.Error("annotated function should not appear in unannotated list")
+		}
+	}
+}
+
+func TestLint_SkipsTestNodesForUnannotated(t *testing.T) {
+	db := newLintTestDB(t)
+	outDir := t.TempDir()
+
+	// Test function — should not be reported as unannotated
+	db.Create(&model.Node{
+		QualifiedName: "pkg/a_test.go::TestFoo",
+		Kind:          model.NodeKindTest,
+		Name:          "TestFoo",
+		FilePath:      "pkg/a_test.go",
+		StartLine:     1, EndLine: 10,
+		Hash: "h1", Language: "go",
+	})
+
+	gen := &Generator{DB: db, OutDir: outDir}
+	report, err := gen.Lint()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if len(report.Unannotated) != 0 {
+		t.Errorf("test nodes should not be in unannotated list, got: %v", report.Unannotated)
+	}
+}