feat(lip): add QueryOutgoingImpact client against v2.3.3 shape

Mirrors query_blast_radius_symbol for the forward direction. Returns
an OutgoingImpactEntry with target_uri, direct_items (callees at
distance=1), transitive_items (distance>=2), semantic_items (seeded
from the target's embedding), edges_source, and truncated — the same
provenance and coupling vocabulary as blast radius so folds can be
routed through the shared ExternalBlastRadius pipeline.

OutgoingEntryToExternal converts the wire entry to the shared shape
with RiskLevel empty — outgoing impact doesn't carry its own
classification; CKB will derive one from the unioned callee set when
the analyzer path is wired.

Adds DirectCallee/TransitiveCallee ImpactKinds so folded items
classify correctly once the analyzer fold lands. Analyzer + CLI/MCP
surface are deferred until LIP v2.3.3 ships and the wire contract is
verified end-to-end.

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

Author: SimplyLiz

internal/impact/classification.go

@@ -6,6 +6,8 @@ type ImpactKind string
 const (
 	DirectCaller        ImpactKind = "direct-caller"
 	TransitiveCaller    ImpactKind = "transitive-caller"
+	DirectCallee        ImpactKind = "direct-callee"     // forward direction: what this symbol calls
+	TransitiveCallee    ImpactKind = "transitive-callee" // forward direction, distance >= 2
 	TypeDependency      ImpactKind = "type-dependency"
 	TestDependency      ImpactKind = "test-dependency"
 	ImplementsInterface ImpactKind = "implements-interface"

internal/lip/blast_radius.go

@@ -105,3 +105,43 @@ func EntryToExternal(entry *BlastRadiusEntry) *impact.ExternalBlastRadius {
 	return ebr
 }
 
+// OutgoingEntryToExternal converts an OutgoingImpactEntry to
+// impact.ExternalBlastRadius so callers can reuse the same fold and merge
+// machinery built for incoming blast radius.
+//
+// The shared Go type does not imply shared semantics: direct_items here are
+// callees (symbols the target invokes), not callers. Consumers must classify
+// folded items with DirectCallee / TransitiveCallee kinds rather than
+// DirectCaller / TransitiveCaller.
+//
+// RiskLevel is intentionally left empty — outgoing impact doesn't carry its
+// own risk classification; CKB derives one from the unioned callee set on
+// receipt.
+func OutgoingEntryToExternal(entry *OutgoingImpactEntry) *impact.ExternalBlastRadius {
+	if entry == nil {
+		return nil
+	}
+	ebr := &impact.ExternalBlastRadius{
+		EdgesSource: entry.EdgesSource,
+	}
+	for _, di := range entry.DirectItems {
+		ebr.DirectItems = append(ebr.DirectItems, impact.ExternalItem{
+			FileURI: di.FileURI, SymbolURI: di.SymbolURI,
+			Distance: di.Distance, Confidence: di.Confidence,
+		})
+	}
+	for _, ti := range entry.TransitiveItems {
+		ebr.TransitiveItems = append(ebr.TransitiveItems, impact.ExternalItem{
+			FileURI: ti.FileURI, SymbolURI: ti.SymbolURI,
+			Distance: ti.Distance, Confidence: ti.Confidence,
+		})
+	}
+	for _, si := range entry.SemanticItems {
+		ebr.SemanticItems = append(ebr.SemanticItems, impact.ExternalSemanticItem{
+			FileURI: si.FileURI, SymbolURI: si.SymbolURI,
+			Similarity: si.Similarity, Source: si.Source,
+		})
+	}
+	return ebr
+}
+

internal/lip/client.go

@@ -856,6 +856,63 @@ func QueryBlastRadiusSymbol(symbolURI string, minScore float32) (*BlastRadiusEnt
 	return raw.Result, nil
 }
 
+// =============================================================================
+// Outgoing impact (v2.3.3)
+// =============================================================================
+
+// OutgoingImpactEntry is the result of a QueryOutgoingImpact call. Shape
+// mirrors BlastRadiusEntry but traces the forward call graph — direct_items
+// are callees at distance=1, transitive_items at distance>=2.
+//
+// target_uri echoes the request's symbol_uri (post-canonicalisation).
+// edges_source and the semantic items reuse the same provenance and coupling
+// vocabulary as blast radius, so callers can treat both results through the
+// shared ExternalBlastRadius pipeline via OutgoingEntryToExternal.
+type OutgoingImpactEntry struct {
+	TargetURI       string                    `json:"target_uri"`
+	DirectItems     []BlastRadiusItem         `json:"direct_items"`
+	TransitiveItems []BlastRadiusItem         `json:"transitive_items"`
+	SemanticItems   []BlastRadiusSemanticItem `json:"semantic_items"`
+	// EdgesSource mirrors BlastRadiusEntry.EdgesSource: "tier1",
+	// "scip_with_tier1_edges", "scip_only", or "empty". Omitted by
+	// daemons that don't yet report provenance — treat as fold-eligible.
+	EdgesSource string `json:"edges_source,omitempty"`
+	Truncated   bool   `json:"truncated"`
+}
+
+type outgoingImpactResp struct {
+	Result *OutgoingImpactEntry `json:"result,omitempty"`
+}
+
+// QueryOutgoingImpact asks LIP for the forward call graph of a symbol
+// (v2.3.3+). Returns (nil, nil) when the symbol isn't indexed, LIP is
+// unavailable, or the daemon doesn't support the RPC — callers should
+// degrade to SCIP-only outgoing traversal.
+//
+// Depth is capped at 8 server-side (matching query_outgoing_calls). Semantic
+// items are seeded from the target's own embedding, same as blast radius.
+//
+// Gate on Handshake.SupportedMessages containing "query_outgoing_impact"
+// before calling — older daemons reject with UnknownMessage.
+func QueryOutgoingImpact(symbolURI string, minScore float32) (*OutgoingImpactEntry, error) {
+	if symbolURI == "" {
+		return nil, nil
+	}
+	req := map[string]any{
+		"type":       "query_outgoing_impact",
+		"symbol_uri": symbolURI,
+	}
+	if minScore > 0 {
+		req["min_score"] = minScore
+	}
+	raw, _ := lipRPC(req, 2*time.Second, 2<<20,
+		func(r outgoingImpactResp) *outgoingImpactResp { return &r })
+	if raw == nil {
+		return nil, nil
+	}
+	return raw.Result, nil
+}
+
 // =============================================================================
 // Annotations
 // =============================================================================

internal/lip/client_test.go

@@ -741,6 +741,141 @@ func TestWireProtocol_RegisterProjectRoot_EmptyRoot(t *testing.T) {
 	}
 }
 
+// =============================================================================
+// Outgoing impact
+// =============================================================================
+
+func TestWireProtocol_QueryOutgoingImpact_WithResult(t *testing.T) {
+	d := newTestDaemon(t, outgoingImpactResp{Result: &OutgoingImpactEntry{
+		TargetURI: "lip://local//repo/foo.go#Caller",
+		DirectItems: []BlastRadiusItem{
+			{FileURI: "lip://local//repo/bar.go", SymbolURI: "lip://local//repo/bar.go#Callee",
+				Distance: 1, Confidence: 0.95},
+		},
+		TransitiveItems: []BlastRadiusItem{
+			{FileURI: "lip://local//repo/baz.go", SymbolURI: "lip://local//repo/baz.go#Deep",
+				Distance: 2, Confidence: 0.85},
+		},
+		SemanticItems: []BlastRadiusSemanticItem{
+			{FileURI: "lip://local//repo/similar.go", SymbolURI: "...#Similar",
+				Similarity: 0.82, Source: "semantic"},
+		},
+		EdgesSource: "scip_with_tier1_edges",
+		Truncated:   false,
+	}})
+
+	got, err := QueryOutgoingImpact("lip://local//repo/foo.go#Caller", 0.6)
+	d.waitHandled(t)
+
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if got == nil {
+		t.Fatal("got nil result")
+	}
+	if got.TargetURI != "lip://local//repo/foo.go#Caller" {
+		t.Errorf("TargetURI = %q", got.TargetURI)
+	}
+	if len(got.DirectItems) != 1 || got.DirectItems[0].Distance != 1 {
+		t.Errorf("DirectItems = %+v", got.DirectItems)
+	}
+	if len(got.TransitiveItems) != 1 || got.TransitiveItems[0].Distance != 2 {
+		t.Errorf("TransitiveItems = %+v", got.TransitiveItems)
+	}
+	if len(got.SemanticItems) != 1 || got.SemanticItems[0].Source != "semantic" {
+		t.Errorf("SemanticItems = %+v", got.SemanticItems)
+	}
+	if got.EdgesSource != "scip_with_tier1_edges" {
+		t.Errorf("EdgesSource = %q", got.EdgesSource)
+	}
+
+	req := d.req()
+	assertField(t, req, "type", "query_outgoing_impact")
+	assertField(t, req, "symbol_uri", "lip://local//repo/foo.go#Caller")
+	assertField(t, req, "min_score", 0.6)
+}
+
+// Null result (target not indexed) must come back as (nil, nil).
+func TestWireProtocol_QueryOutgoingImpact_NullResult(t *testing.T) {
+	d := newTestDaemon(t, outgoingImpactResp{Result: nil})
+
+	got, err := QueryOutgoingImpact("lip://local//repo/unknown.go#X", 0.6)
+	d.waitHandled(t)
+
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if got != nil {
+		t.Errorf("want nil result for unindexed target, got %+v", got)
+	}
+}
+
+// min_score=0 must be omitted so the daemon applies its default.
+func TestWireProtocol_QueryOutgoingImpact_OmitMinScore(t *testing.T) {
+	d := newTestDaemon(t, outgoingImpactResp{})
+
+	_, _ = QueryOutgoingImpact("lip://x#X", 0)
+	d.waitHandled(t)
+
+	req := d.req()
+	assertField(t, req, "type", "query_outgoing_impact")
+	assertField(t, req, "symbol_uri", "lip://x#X")
+	assertNoField(t, req, "min_score")
+}
+
+// Empty symbol URI must short-circuit — no socket call.
+func TestWireProtocol_QueryOutgoingImpact_EmptySymbol(t *testing.T) {
+	prev := os.Getenv("LIP_SOCKET")
+	os.Setenv("LIP_SOCKET", "/tmp/lip-nonexistent-ckb-test.sock")
+	defer os.Setenv("LIP_SOCKET", prev)
+
+	got, err := QueryOutgoingImpact("", 0.6)
+	if got != nil || err != nil {
+		t.Errorf("empty symbol: want (nil, nil), got (%v, %v)", got, err)
+	}
+}
+
+func TestOutgoingEntryToExternal(t *testing.T) {
+	entry := &OutgoingImpactEntry{
+		TargetURI: "lip://x#X",
+		DirectItems: []BlastRadiusItem{
+			{FileURI: "f1", SymbolURI: "f1#A", Distance: 1, Confidence: 0.9},
+		},
+		TransitiveItems: []BlastRadiusItem{
+			{FileURI: "f2", SymbolURI: "f2#B", Distance: 2, Confidence: 0.8},
+		},
+		SemanticItems: []BlastRadiusSemanticItem{
+			{FileURI: "f3", SymbolURI: "f3#C", Similarity: 0.75, Source: "both"},
+		},
+		EdgesSource: "tier1",
+	}
+	ext := OutgoingEntryToExternal(entry)
+	if ext == nil {
+		t.Fatal("got nil")
+	}
+	if len(ext.DirectItems) != 1 || ext.DirectItems[0].SymbolURI != "f1#A" {
+		t.Errorf("DirectItems: %+v", ext.DirectItems)
+	}
+	if len(ext.TransitiveItems) != 1 || ext.TransitiveItems[0].Distance != 2 {
+		t.Errorf("TransitiveItems: %+v", ext.TransitiveItems)
+	}
+	if len(ext.SemanticItems) != 1 || ext.SemanticItems[0].Source != "both" {
+		t.Errorf("SemanticItems: %+v", ext.SemanticItems)
+	}
+	if ext.EdgesSource != "tier1" {
+		t.Errorf("EdgesSource = %q", ext.EdgesSource)
+	}
+	if ext.RiskLevel != "" {
+		t.Errorf("RiskLevel should be empty for outgoing, got %q", ext.RiskLevel)
+	}
+}
+
+func TestOutgoingEntryToExternal_Nil(t *testing.T) {
+	if got := OutgoingEntryToExternal(nil); got != nil {
+		t.Errorf("nil entry: want nil, got %+v", got)
+	}
+}
+
 func TestWireProtocol_Handshake(t *testing.T) {
 	d := newTestDaemon(t, handshakeResp{DaemonVersion: "2.0.0", ProtocolVersion: 2})