anchor-trace-horizontal-extension

Trace dependencies upward and downward from an anchor file across layers to generate a minimal extension plan.

Updated Feb 4, 2026
One-click install
npx skills add https://github.com/zhaowendao2005/HNULS-LuminaStudio --skill anchor-trace-horizontal-extension
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: anchor-trace-horizontal-extension
Source: https://github.com/zhaowendao2005/HNULS-LuminaStudio/tree/main/.agent/skills/anchor-trace-horizontal-extension
Command: npx skills add https://github.com/zhaowendao2005/HNULS-LuminaStudio --skill anchor-trace-horizontal-extension

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Trace dependencies across multiple architecture layers starting from a user-selected anchor file to understand how code is connected, identify which parts perform work vs pass through data, and expose a minimal, actionable cross-layer extension plan to guide refactors.

Core Features & Use Cases

  • Bi-directional tracing: from the anchor, identify both consumers that depend on the anchor and the dependencies the anchor relies on across Renderer, Preload, Main, Utility, and Shared layers.
  • Layer mapping: categorize files into Renderer, Preload, Main, Utility, and Shared layers and determine processing vs passthrough roles.
  • Extension planning: generate a concise cross-layer plan that outlines required changes to implement a new feature or refactor with minimal disruption.
  • Use Case: a developer starts from an anchor module to propose a safe extension plan for cross-layer feature work, reducing integration risk.

Quick Start

Provide an anchor file path to begin the trace and generate a minimal cross-layer extension plan.

Frequently Asked Questions about anchor-trace-horizontal-extension

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I trace dependencies across multiple architecture layers from a single file?

Trace dependencies across multiple architecture layers by selecting an anchor file to map both upward consumers and downward dependencies. This bi-directional tracing identifies which components belong to Renderer, Preload, Main, Utility, and Shared layers.

What is the best way to plan a cross-layer feature extension without breaking existing code?

Plan a cross-layer feature extension by generating a minimal, deterministic plan from an anchor file. This approach distinguishes processing versus passthrough layers to outline required changes and reduce integration risk during refactors.

How do I identify which files are processing data versus just passing it through during a refactor?

Identify processing versus passthrough files by mapping imports and exports across architecture layers. The trace categorizes each component's role to expose which modules perform work and which just route data.

Can I use a single anchor file to map dependencies across Renderer, Preload, and Main layers?

Yes, you can map dependencies across Renderer, Preload, Main, Utility, and Shared layers from a single anchor file. The trace identifies both who imports the anchor and who the anchor imports across these specific architecture boundaries.

How do I generate a reproducible extension plan for cross-layer architecture changes?

Generate a reproducible extension plan by enforcing a disciplined anchor-based dependency trace. This deterministic process maps cross-layer connections and outputs a concise, actionable plan for implementing new features with minimal disruption.