feat(lip): wire query_outgoing_impact through engine, CLI, and MCP

Surfaces LIP v2.3.5's forward call graph ("what does X call?") as a
first-class CKB operation mirroring AnalyzeImpact in the reverse
direction. Requires a daemon advertising query_outgoing_impact;
degrades to an empty response with a provenance warning when the RPC
isn't supported.

- Engine: Engine.AnalyzeOutgoingImpact in internal/query, driven by
  the shared LIP fold pipeline via impact.FoldExternalCalleeItems.
- impact: new FoldExternalCalleeItems twin of FoldExternalStaticItems,
  both delegating to a shared kind-parameterised fold. Fixed a latent
  distance-default bug that treated DirectCallee items as distance=2.
- CLI: ckb impact outgoing <symbolId> with --min-score / --format.
  ProvenanceCLI gained a Warnings field so LIP-unavailable surfaces
  cleanly in JSON output.
- MCP: analyzeOutgoingImpact tool registered and dispatched.

Tests cover the engine method against a fake daemon, the fold-level
kind tagging and dedup semantics, and the lip→impact seam end-to-end.

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

Author: SimplyLiz

cmd/ckb/impact.go

@@ -39,6 +39,9 @@ var (
 	// prepareChange subcommand flags
 	prepareChangeFormat     string
 	prepareChangeChangeType string
+	// outgoing subcommand flags
+	impactOutgoingMinScore float32
+	impactOutgoingFormat   string
 )
 
 var impactCmd = &cobra.Command{
@@ -75,6 +78,25 @@ Examples:
 	Run:  runPrepareChange,
 }
 
+var impactOutgoingCmd = &cobra.Command{
+	Use:   "outgoing <symbolId>",
+	Short: "Analyze what a symbol calls (forward call graph)",
+	Long: `Analyze the forward call graph of a symbol — what it calls directly
+and transitively. Mirrors 'ckb impact <symbolId>' but in the opposite
+direction.
+
+Requires a LIP daemon advertising query_outgoing_impact (LIP v2.3.5+).
+When LIP is unavailable the response carries the symbol metadata with
+empty callee lists and a provenance warning.
+
+Examples:
+  ckb impact outgoing DoWork
+  ckb impact outgoing DoWork --min-score=0.6
+  ckb impact outgoing DoWork --format=json`,
+	Args: cobra.ExactArgs(1),
+	Run:  runImpactOutgoing,
+}
+
 var impactDiffCmd = &cobra.Command{
 	Use:   "diff",
 	Short: "Analyze impact of code changes",
@@ -112,8 +134,13 @@ func init() {
 	prepareChangeCmd.Flags().StringVar(&prepareChangeFormat, "format", "full", "Output format (full, compact)")
 	prepareChangeCmd.Flags().StringVar(&prepareChangeChangeType, "change-type", "modify", "Change type (modify, rename, delete, extract, move)")
 
+	// outgoing subcommand flags
+	impactOutgoingCmd.Flags().Float32Var(&impactOutgoingMinScore, "min-score", 0.6, "Minimum cosine similarity for semantic callees (0 disables semantic enrichment)")
+	impactOutgoingCmd.Flags().StringVar(&impactOutgoingFormat, "format", "human", "Output format (human, json)")
+
 	impactCmd.AddCommand(impactDiffCmd)
 	impactCmd.AddCommand(prepareChangeCmd)
+	impactCmd.AddCommand(impactOutgoingCmd)
 	rootCmd.AddCommand(impactCmd)
 }
 
@@ -805,3 +832,135 @@ func formatImpactMarkdown(resp *ChangeSetResponseCLI) string {
 
 	return b.String()
 }
+
+// OutgoingImpactResponseCLI is the CLI-facing view of
+// query.AnalyzeOutgoingImpactResponse.
+type OutgoingImpactResponseCLI struct {
+	SymbolID          string                  `json:"symbolId"`
+	Symbol            *SymbolInfoCLI          `json:"symbol,omitempty"`
+	DirectCallees     []ImpactItemCLI         `json:"directCallees"`
+	TransitiveCallees []ImpactItemCLI         `json:"transitiveCallees,omitempty"`
+	SemanticCallees   []SemanticCalleeInfoCLI `json:"semanticCallees,omitempty"`
+	EdgesSource       string                  `json:"edgesSource,omitempty"`
+	Truncated         bool                    `json:"truncated,omitempty"`
+	Provenance        *ProvenanceCLI          `json:"provenance,omitempty"`
+}
+
+// SemanticCalleeInfoCLI represents an embedding-similar coupled callee.
+type SemanticCalleeInfoCLI struct {
+	SymbolURI  string  `json:"symbolUri,omitempty"`
+	FileURI    string  `json:"fileUri"`
+	Similarity float32 `json:"similarity"`
+	Source     string  `json:"source"`
+}
+
+func runImpactOutgoing(cmd *cobra.Command, args []string) {
+	start := time.Now()
+	logger := newLogger(impactOutgoingFormat)
+	symbolID := args[0]
+
+	repoRoot := mustGetRepoRoot()
+	engine := mustGetEngine(repoRoot, logger)
+	ctx := newContext()
+
+	resp, err := engine.AnalyzeOutgoingImpact(ctx, query.AnalyzeOutgoingImpactOptions{
+		SymbolId: symbolID,
+		MinScore: impactOutgoingMinScore,
+	})
+	if err != nil {
+		if strings.Contains(err.Error(), "not found") {
+			fmt.Fprint(os.Stderr, formatSymbolNotFoundError(symbolID))
+			os.Exit(1)
+		}
+		fmt.Fprintf(os.Stderr, "Error analyzing outgoing impact: %v\n", err)
+		os.Exit(1)
+	}
+
+	cliResp := convertOutgoingImpactResponse(symbolID, resp)
+	output, err := FormatResponse(cliResp, OutputFormat(impactOutgoingFormat))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error formatting output: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Println(output)
+
+	logger.Debug("Outgoing impact analysis completed",
+		"symbolId", symbolID,
+		"direct", len(resp.DirectCallees),
+		"transitive", len(resp.TransitiveCallees),
+		"duration", time.Since(start).Milliseconds(),
+	)
+}
+
+func convertOutgoingImpactResponse(symbolID string, resp *query.AnalyzeOutgoingImpactResponse) *OutgoingImpactResponseCLI {
+	direct := make([]ImpactItemCLI, 0, len(resp.DirectCallees))
+	for _, item := range resp.DirectCallees {
+		direct = append(direct, impactItemToCLI(item))
+	}
+	transitive := make([]ImpactItemCLI, 0, len(resp.TransitiveCallees))
+	for _, item := range resp.TransitiveCallees {
+		transitive = append(transitive, impactItemToCLI(item))
+	}
+	semantic := make([]SemanticCalleeInfoCLI, 0, len(resp.SemanticCallees))
+	for _, s := range resp.SemanticCallees {
+		semantic = append(semantic, SemanticCalleeInfoCLI{
+			SymbolURI:  s.SymbolURI,
+			FileURI:    s.FileURI,
+			Similarity: s.Similarity,
+			Source:     s.Source,
+		})
+	}
+
+	out := &OutgoingImpactResponseCLI{
+		SymbolID:          symbolID,
+		DirectCallees:     direct,
+		TransitiveCallees: transitive,
+		SemanticCallees:   semantic,
+		EdgesSource:       resp.EdgesSource,
+		Truncated:         resp.Truncated,
+	}
+	if resp.Symbol != nil {
+		visibility := "unknown"
+		confidence := 0.0
+		if resp.Symbol.Visibility != nil {
+			visibility = resp.Symbol.Visibility.Visibility
+			confidence = resp.Symbol.Visibility.Confidence
+		}
+		out.Symbol = &SymbolInfoCLI{
+			StableID:             resp.Symbol.StableId,
+			Name:                 resp.Symbol.Name,
+			Kind:                 resp.Symbol.Kind,
+			Visibility:           visibility,
+			VisibilityConfidence: confidence,
+		}
+	}
+	if resp.Provenance != nil {
+		out.Provenance = &ProvenanceCLI{
+			RepoStateId:     resp.Provenance.RepoStateId,
+			RepoStateDirty:  resp.Provenance.RepoStateDirty,
+			QueryDurationMs: resp.Provenance.QueryDurationMs,
+			Warnings:        resp.Provenance.Warnings,
+		}
+	}
+	return out
+}
+
+func impactItemToCLI(item query.ImpactItem) ImpactItemCLI {
+	cli := ImpactItemCLI{
+		StableID:   item.StableId,
+		Name:       item.Name,
+		Kind:       item.Kind,
+		Distance:   item.Distance,
+		ModuleID:   item.ModuleId,
+		Confidence: item.Confidence,
+	}
+	if item.Location != nil {
+		cli.Location = &LocationCLI{
+			FileID:      item.Location.FileId,
+			Path:        item.Location.FileId,
+			StartLine:   item.Location.StartLine,
+			StartColumn: item.Location.StartColumn,
+		}
+	}
+	return cli
+}

cmd/ckb/symbol.go

@@ -114,9 +114,10 @@ type ModuleInfoCLI struct {
 
 // ProvenanceCLI contains response metadata
 type ProvenanceCLI struct {
-	RepoStateId     string `json:"repoStateId"`
-	RepoStateDirty  bool   `json:"repoStateDirty"`
-	QueryDurationMs int64  `json:"queryDurationMs"`
+	RepoStateId     string   `json:"repoStateId"`
+	RepoStateDirty  bool     `json:"repoStateDirty"`
+	QueryDurationMs int64    `json:"queryDurationMs"`
+	Warnings        []string `json:"warnings,omitempty"`
 }
 
 func convertSymbolResponse(resp *query.GetSymbolResponse) *SymbolResponseCLI {

internal/impact/enricher.go

@@ -166,6 +166,32 @@ func FoldExternalStaticItems(
 	direct, transitive []ImpactItem,
 	external *ExternalBlastRadius,
 	repoRoot string,
+) (foldedDirect, foldedTransitive []ImpactItem) {
+	return foldExternalItemsWithKinds(direct, transitive, external, repoRoot, DirectCaller, TransitiveCaller)
+}
+
+// FoldExternalCalleeItems is the forward-direction twin of
+// FoldExternalStaticItems, tagging folded items with DirectCallee /
+// TransitiveCallee. Used by Engine.AnalyzeOutgoingImpact to fold LIP's
+// query_outgoing_impact result into the shared ImpactItem pipeline.
+//
+// Unlike the incoming path there is typically no SCIP-derived list to merge
+// against — callers usually pass nil for direct/transitive and get back a
+// pure LIP-derived set. Dedup semantics are identical to the incoming fold,
+// so passing non-nil inputs is also supported for future SCIP forward BFS.
+func FoldExternalCalleeItems(
+	direct, transitive []ImpactItem,
+	external *ExternalBlastRadius,
+	repoRoot string,
+) (foldedDirect, foldedTransitive []ImpactItem) {
+	return foldExternalItemsWithKinds(direct, transitive, external, repoRoot, DirectCallee, TransitiveCallee)
+}
+
+func foldExternalItemsWithKinds(
+	direct, transitive []ImpactItem,
+	external *ExternalBlastRadius,
+	repoRoot string,
+	directKind, transitiveKind ImpactKind,
 ) (foldedDirect, foldedTransitive []ImpactItem) {
 	if external == nil || external.EdgesSource == EdgesSourceEmpty {
 		return direct, transitive
@@ -183,7 +209,7 @@ func FoldExternalStaticItems(
 	foldedTransitive = transitive
 
 	for _, ei := range external.DirectItems {
-		item, key, ok := externalItemToImpactItem(ei, DirectCaller)
+		item, key, ok := externalItemToImpactItem(ei, directKind)
 		if !ok {
 			continue
 		}
@@ -194,7 +220,7 @@ func FoldExternalStaticItems(
 		foldedDirect = append(foldedDirect, item)
 	}
 	for _, ei := range external.TransitiveItems {
-		item, key, ok := externalItemToImpactItem(ei, TransitiveCaller)
+		item, key, ok := externalItemToImpactItem(ei, transitiveKind)
 		if !ok {
 			continue
 		}
@@ -220,7 +246,7 @@ func externalItemToImpactItem(ei ExternalItem, kind ImpactKind) (ImpactItem, str
 	}
 	distance := ei.Distance
 	if distance == 0 {
-		if kind == DirectCaller {
+		if kind == DirectCaller || kind == DirectCallee {
 			distance = 1
 		} else {
 			distance = 2

internal/impact/enricher_test.go

@@ -233,6 +233,70 @@ func TestFoldExternalStaticItems_DistanceDefault(t *testing.T) {
 	}
 }
 
+func TestFoldExternalCalleeItems_TagsCalleeKinds(t *testing.T) {
+	// Mirrors the Caller test pattern, but asserts items are tagged with
+	// DirectCallee / TransitiveCallee rather than the caller kinds. Guards
+	// against accidental cross-wiring of foldExternalItemsWithKinds.
+	external := &ExternalBlastRadius{
+		EdgesSource: EdgesSourceScipWithTier1Edges,
+		DirectItems: []ExternalItem{
+			{SymbolURI: "lip://local//repo/a.go#A", Distance: 1, Confidence: 0.95},
+		},
+		TransitiveItems: []ExternalItem{
+			{SymbolURI: "lip://local//repo/b.go#B", Distance: 2, Confidence: 0.85},
+		},
+	}
+	gotD, gotT := FoldExternalCalleeItems(nil, nil, external, "/repo")
+	if len(gotD) != 1 || gotD[0].Kind != DirectCallee {
+		t.Errorf("direct kind = %q, want %q", gotD[0].Kind, DirectCallee)
+	}
+	if len(gotT) != 1 || gotT[0].Kind != TransitiveCallee {
+		t.Errorf("transitive kind = %q, want %q", gotT[0].Kind, TransitiveCallee)
+	}
+}
+
+func TestFoldExternalCalleeItems_NilAndEmpty(t *testing.T) {
+	// Short-circuits mirror the caller twin — nil external and "empty"
+	// EdgesSource both must leave the input lists unchanged.
+	seed := []ImpactItem{{Name: "seed", Kind: DirectCallee, Distance: 1}}
+
+	gotD, gotT := FoldExternalCalleeItems(seed, nil, nil, "/repo")
+	if len(gotD) != 1 || len(gotT) != 0 {
+		t.Errorf("nil external: direct=%d trans=%d, want 1/0", len(gotD), len(gotT))
+	}
+
+	gotD, _ = FoldExternalCalleeItems(seed, nil, &ExternalBlastRadius{
+		EdgesSource: EdgesSourceEmpty,
+		DirectItems: []ExternalItem{
+			{SymbolURI: "lip://local//repo/a.go#A", Distance: 1},
+		},
+	}, "/repo")
+	if len(gotD) != 1 {
+		t.Errorf("empty EdgesSource: direct=%d, want 1 (unchanged)", len(gotD))
+	}
+}
+
+func TestFoldExternalCalleeItems_DistanceDefault(t *testing.T) {
+	// Distance=0 from LIP should default to 1 for direct, 2 for transitive —
+	// same semantics as the caller path.
+	external := &ExternalBlastRadius{
+		EdgesSource: EdgesSourceScipOnly,
+		DirectItems: []ExternalItem{
+			{SymbolURI: "lip://local//repo/a.go#A", Confidence: 0.95},
+		},
+		TransitiveItems: []ExternalItem{
+			{SymbolURI: "lip://local//repo/b.go#B", Confidence: 0.85},
+		},
+	}
+	gotD, gotT := FoldExternalCalleeItems(nil, nil, external, "/repo")
+	if gotD[0].Distance != 1 {
+		t.Errorf("direct default distance = %d, want 1", gotD[0].Distance)
+	}
+	if gotT[0].Distance != 2 {
+		t.Errorf("transitive default distance = %d, want 2", gotT[0].Distance)
+	}
+}
+
 func TestMergeBlastRadius_DedupByFile(t *testing.T) {
 	static := &BlastRadius{
 		UniqueCallerCount: 2,

internal/mcp/presets_test.go

@@ -42,9 +42,9 @@ func TestPresetFiltering(t *testing.T) {
 		t.Fatalf("failed to set full preset: %v", err)
 	}
 	fullTools := server.GetFilteredTools()
-	// v8.5: +3 Cartographer (shotgunSurgery, evolution, blastRadius) +3 LIP annotation tools = 107; +1 symbolExists = 108; +1 (full includes the expanded presets) = 109
-	if len(fullTools) != 109 {
-		t.Errorf("expected 109 full tools, got %d", len(fullTools))
+	// v8.5: +3 Cartographer (shotgunSurgery, evolution, blastRadius) +3 LIP annotation tools = 107; +1 symbolExists = 108; +1 (full includes the expanded presets) = 109; +1 analyzeOutgoingImpact = 110
+	if len(fullTools) != 110 {
+		t.Errorf("expected 110 full tools, got %d", len(fullTools))
 	}
 
 	// Full preset should still have core tools first

internal/mcp/token_budget_test.go

@@ -35,7 +35,7 @@ func TestToolsListTokenBudget(t *testing.T) {
 	}{
 		{PresetCore, maxCorePresetBytes, 20, 25},     // v8.3: 24 tools (+explainPath, responsibilities, exportForLLM); +1 symbolExists = 25
 		{PresetReview, maxReviewPresetBytes, 30, 42}, // v8.4: 41 tools (+findUnwiredModules); +1 symbolExists = 42
-		{PresetFull, maxFullPresetBytes, 80, 109},    // v8.5: 107 tools (+3 Cartographer, +3 LIP annotation); +1 symbolExists in all presets = 109
+		{PresetFull, maxFullPresetBytes, 80, 110},    // v8.5: 107 tools (+3 Cartographer, +3 LIP annotation); +1 symbolExists in all presets = 109; +1 analyzeOutgoingImpact = 110
 	}
 
 	for _, tt := range tests {